◆ Derive() [2/2]

static void System.Security.Cryptography.Pkcs.Pkcs12Kdf.Derive	(	ReadOnlySpan< char >	password,
		HashAlgorithmName	hashAlgorithm,
		int	iterationCount,
		byte	id,
		ReadOnlySpan< byte >	salt,
		Span< byte >	destination )
inlinestaticprivate
Definition at line 26 of file Pkcs12Kdf.cs.
    {
        int num = -1;
        int num2 = -1;
        (HashAlgorithmName, int, int)[] array = s_uvLookup;
        for (int i = 0; i < array.Length; i++)
        {
            (HashAlgorithmName, int, int) tuple = array[i];
            if (tuple.Item1 == hashAlgorithm)
            {
                num = tuple.Item2;
                num2 = tuple.Item3;
                break;
            }
        }
        if (num == -1)
        {
            throw new CryptographicException(System.SR.Cryptography_UnknownHashAlgorithm, hashAlgorithm.Name);
        }
        int num3 = num2 >> 3;
        Span<byte> span = stackalloc byte[num3];
        span.Fill(id);
        int num4 = (salt.Length - 1 + num3) / num3 * num3;
        int num5 = checked((password.Length + 1) * 2);
        if (password == default(ReadOnlySpan<char>))
        {
            num5 = 0;
        }
        int num6 = (num5 - 1 + num3) / num3 * num3;
        int num7 = num4 + num6;
        Span<byte> span2 = default(Span<byte>);
        byte[] array2 = null;
        if (num7 <= 1024)
        {
            span2 = stackalloc byte[num7];
        }
        else
        {
            array2 = System.Security.Cryptography.CryptoPool.Rent(num7);
            span2 = array2.AsSpan(0, num7);
        }
        IncrementalHash incrementalHash = IncrementalHash.CreateHash(hashAlgorithm);
        try
        {
            CircularCopy(salt, span2.Slice(0, num4));
            CircularCopyUtf16BE(password, span2.Slice(num4));
            Span<byte> span3 = stackalloc byte[num >> 3];
            Span<byte> span4 = stackalloc byte[num3];
            while (true)
            {
                incrementalHash.AppendData(span);
                incrementalHash.AppendData(span2);
                for (int num8 = iterationCount; num8 > 0; num8--)
                {
                    if (!incrementalHash.TryGetHashAndReset(span3, out var bytesWritten) || bytesWritten != span3.Length)
                    {
                        throw new CryptographicException();
                    }
                    if (num8 != 1)
                    {
                        incrementalHash.AppendData(span3);
                    }
                }
                if (span3.Length >= destination.Length)
                {
                    break;
                }
                span3.CopyTo(destination);
                destination = destination.Slice(span3.Length);
                CircularCopy(span3, span4);
                for (int num9 = span2.Length / num3 - 1; num9 >= 0; num9--)
                {
                    Span<byte> into = span2.Slice(num9 * num3, num3);
                    AddPlusOne(into, span4);
                }
            }
            span3.Slice(0, destination.Length).CopyTo(destination);
        }
        finally
        {
            CryptographicOperations.ZeroMemory(span2);
            if (array2 != null)
            {
                System.Security.Cryptography.CryptoPool.Return(array2, 0);
            }
            incrementalHash.Dispose();
        }
    }