ReadAsyncCore()

async ValueTask< int > System.Security.Cryptography.CryptoStream.ReadAsyncCore ( Memory< byte > buffer, CancellationToken cancellationToken, bool useAsync )

inlineprivate

Definition at line 285 of file CryptoStream.cs.

    {
        while (true)
        {
            if (_outputBufferIndex != 0)
            {
                int num = Math.Min(_outputBufferIndex, buffer.Length);
                if (num != 0)
                {
                    new ReadOnlySpan<byte>(_outputBuffer, 0, num).CopyTo(buffer.Span);
                    _outputBufferIndex -= num;
                    _outputBuffer.AsSpan(num).CopyTo(_outputBuffer);
                    CryptographicOperations.ZeroMemory(_outputBuffer.AsSpan(_outputBufferIndex, num));
                }
                return num;
            }
            if (_finalBlockTransformed)
            {
                break;
            }
            int num2 = 0;
            bool flag = false;
            int num3 = buffer.Length / _outputBlockSize;
            if (num3 > 1 && _transform.CanTransformMultipleBlocks)
            {
                int numWholeBlocksInBytes = checked(num3 * _inputBlockSize);
                byte[] tempInputBuffer = ArrayPool<byte>.Shared.Rent(numWholeBlocksInBytes);
                try
                {
                    int num4 = ((!useAsync) ? _stream.Read(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex) : (await _stream.ReadAsync(new Memory<byte>(tempInputBuffer, _inputBufferIndex, numWholeBlocksInBytes - _inputBufferIndex), cancellationToken).ConfigureAwait(continueOnCapturedContext: false)));
                    num2 = num4;
                    flag = num2 == 0;
                    int num5 = _inputBufferIndex + num2;
                    if (num5 >= _inputBlockSize)
                    {
                        Buffer.BlockCopy(_inputBuffer, 0, tempInputBuffer, 0, _inputBufferIndex);
                        CryptographicOperations.ZeroMemory(new Span<byte>(_inputBuffer, 0, _inputBufferIndex));
                        num2 += _inputBufferIndex;
                        int num6 = num2 / _inputBlockSize;
                        int num7 = num6 * _inputBlockSize;
                        _inputBufferIndex = num2 - num7;
                        if (_inputBufferIndex != 0)
                        {
                            Buffer.BlockCopy(tempInputBuffer, num7, _inputBuffer, 0, _inputBufferIndex);
                        }
                        int num8;
                        if (MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)buffer, out ArraySegment<byte> segment))
                        {
                            num8 = _transform.TransformBlock(tempInputBuffer, 0, num7, segment.Array, segment.Offset);
                        }
                        else
                        {
                            byte[] array = ArrayPool<byte>.Shared.Rent(num6 * _outputBlockSize);
                            num8 = num6 * _outputBlockSize;
                            try
                            {
                                num8 = _transform.TransformBlock(tempInputBuffer, 0, num7, array, 0);
                                array.AsSpan(0, num8).CopyTo(buffer.Span);
                            }
                            finally
                            {
                                CryptographicOperations.ZeroMemory(new Span<byte>(array, 0, num8));
                                ArrayPool<byte>.Shared.Return(array);
                            }
                        }
                        if (num8 != 0)
                        {
                            return num8;
                        }
                    }
                    else
                    {
                        Buffer.BlockCopy(tempInputBuffer, _inputBufferIndex, _inputBuffer, _inputBufferIndex, num2);
                        _inputBufferIndex = num5;
                    }
                }
                finally
                {
                    CryptographicOperations.ZeroMemory(new Span<byte>(tempInputBuffer, 0, numWholeBlocksInBytes));
                    ArrayPool<byte>.Shared.Return(tempInputBuffer);
                }
            }
            if (!flag)
            {
                while (_inputBufferIndex < _inputBlockSize)
                {
                    int num9 = ((!useAsync) ? _stream.Read(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex) : (await _stream.ReadAsync(new Memory<byte>(_inputBuffer, _inputBufferIndex, _inputBlockSize - _inputBufferIndex), cancellationToken).ConfigureAwait(continueOnCapturedContext: false)));
                    num2 = num9;
                    if (num2 <= 0)
                    {
                        break;
                    }
                    _inputBufferIndex += num2;
                }
            }
            if (num2 <= 0)
            {
                _outputBuffer = _transform.TransformFinalBlock(_inputBuffer, 0, _inputBufferIndex);
                _outputBufferIndex = _outputBuffer.Length;
                _finalBlockTransformed = true;
            }
            else
            {
                _outputBufferIndex = _transform.TransformBlock(_inputBuffer, 0, _inputBufferIndex, _outputBuffer, 0);
            }
            _inputBufferIndex = 0;
        }
        return 0;
    }

References System.Security.Cryptography.CryptoStream._finalBlockTransformed, System.Security.Cryptography.CryptoStream._inputBlockSize, System.Security.Cryptography.CryptoStream._inputBuffer, System.Security.Cryptography.CryptoStream._inputBufferIndex, System.Security.Cryptography.CryptoStream._outputBlockSize, System.Security.Cryptography.CryptoStream._outputBuffer, System.Security.Cryptography.CryptoStream._outputBufferIndex, System.Security.Cryptography.CryptoStream._stream, System.Security.Cryptography.CryptoStream._transform, System.array, System.Buffer.BlockCopy(), System.buffer, System.cancellationToken, System.Security.Cryptography.ICryptoTransform.CanTransformMultipleBlocks, System.ReadOnlySpan< T >.CopyTo(), System.Math.Min(), System.IO.Stream.Read(), System.IO.Stream.ReadAsync(), System.Buffers.ArrayPool< T >.Shared, System.Security.Cryptography.ICryptoTransform.TransformBlock(), System.Security.Cryptography.ICryptoTransform.TransformFinalBlock(), and System.Security.Cryptography.CryptographicOperations.ZeroMemory().

Referenced by System.Security.Cryptography.CryptoStream.Read(), and System.Security.Cryptography.CryptoStream.ReadAsyncInternal().