WriteAsyncCore()

async ValueTask System.Security.Cryptography.CryptoStream.WriteAsyncCore ( ReadOnlyMemory< byte > buffer, CancellationToken cancellationToken, bool useAsync )

inlineprivate

Definition at line 448 of file CryptoStream.cs.

    {
        int bytesToWrite = buffer.Length;
        int currentInputIndex = 0;
        if (_inputBufferIndex > 0)
        {
            if (buffer.Length < _inputBlockSize - _inputBufferIndex)
            {
                buffer.CopyTo(_inputBuffer.AsMemory(_inputBufferIndex));
                _inputBufferIndex += buffer.Length;
                return;
            }
            buffer.Slice(0, _inputBlockSize - _inputBufferIndex).CopyTo(_inputBuffer.AsMemory(_inputBufferIndex));
            currentInputIndex += _inputBlockSize - _inputBufferIndex;
            bytesToWrite -= _inputBlockSize - _inputBufferIndex;
            _inputBufferIndex = _inputBlockSize;
        }
        if (_inputBufferIndex == _inputBlockSize)
        {
            int numOutputBytes2 = _transform.TransformBlock(_inputBuffer, 0, _inputBlockSize, _outputBuffer, 0);
            if (useAsync)
            {
                await _stream.WriteAsync(new ReadOnlyMemory<byte>(_outputBuffer, 0, numOutputBytes2), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
            }
            else
            {
                _stream.Write(_outputBuffer, 0, numOutputBytes2);
            }
            _inputBufferIndex = 0;
        }
        while (bytesToWrite > 0)
        {
            if (bytesToWrite >= _inputBlockSize)
            {
                int num = bytesToWrite / _inputBlockSize;
                if (_transform.CanTransformMultipleBlocks && num > 1)
                {
                    int numWholeBlocksInBytes = num * _inputBlockSize;
                    byte[] tempOutputBuffer = ArrayPool<byte>.Shared.Rent(checked(num * _outputBlockSize));
                    int numOutputBytes2 = 0;
                    try
                    {
                        numOutputBytes2 = TransformBlock(_transform, buffer.Slice(currentInputIndex, numWholeBlocksInBytes), tempOutputBuffer, 0);
                        if (useAsync)
                        {
                            await _stream.WriteAsync(new ReadOnlyMemory<byte>(tempOutputBuffer, 0, numOutputBytes2), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                        }
                        else
                        {
                            _stream.Write(tempOutputBuffer, 0, numOutputBytes2);
                        }
                        currentInputIndex += numWholeBlocksInBytes;
                        bytesToWrite -= numWholeBlocksInBytes;
                        CryptographicOperations.ZeroMemory(new Span<byte>(tempOutputBuffer, 0, numOutputBytes2));
                        ArrayPool<byte>.Shared.Return(tempOutputBuffer);
                        tempOutputBuffer = null;
                    }
                    catch
                    {
                        CryptographicOperations.ZeroMemory(new Span<byte>(tempOutputBuffer, 0, numOutputBytes2));
                        throw;
                    }
                }
                else
                {
                    int numOutputBytes2 = TransformBlock(_transform, buffer.Slice(currentInputIndex, _inputBlockSize), _outputBuffer, 0);
                    if (useAsync)
                    {
                        await _stream.WriteAsync(new ReadOnlyMemory<byte>(_outputBuffer, 0, numOutputBytes2), cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
                    }
                    else
                    {
                        _stream.Write(_outputBuffer, 0, numOutputBytes2);
                    }
                    currentInputIndex += _inputBlockSize;
                    bytesToWrite -= _inputBlockSize;
                }
                continue;
            }
            buffer.Slice(currentInputIndex, bytesToWrite).CopyTo(_inputBuffer);
            _inputBufferIndex += bytesToWrite;
            break;
        }
        unsafe static int TransformBlock(ICryptoTransform transform, ReadOnlyMemory<byte> inputBuffer, byte[] outputBuffer, int outputOffset)
        {
            if (MemoryMarshal.TryGetArray(inputBuffer, out var segment))
            {
                return transform.TransformBlock(segment.Array, segment.Offset, inputBuffer.Length, outputBuffer, outputOffset);
            }
            byte[] array = ArrayPool<byte>.Shared.Rent(inputBuffer.Length);
            int result = 0;
            fixed (byte* ptr = &array[0])
            {
                try
                {
                    inputBuffer.CopyTo(array);
                    result = transform.TransformBlock(array, 0, inputBuffer.Length, outputBuffer, outputOffset);
                }
                finally
                {
                    CryptographicOperations.ZeroMemory(array.AsSpan(0, inputBuffer.Length));
                }
            }
            ArrayPool<byte>.Shared.Return(array);
            array = null;
            return result;
        }
    }

References 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._stream, System.Security.Cryptography.CryptoStream._transform, System.array, System.buffer, System.cancellationToken, System.Security.Cryptography.ICryptoTransform.CanTransformMultipleBlocks, System.Threading.Tasks.Task< TResult >.ConfigureAwait(), System.ReadOnlyMemory< T >.CopyTo(), System.ReadOnlyMemory< T >.Length, System.Buffers.ArrayPool< T >.Shared, System.Security.Cryptography.ICryptoTransform.TransformBlock(), System.IO.Stream.Write(), System.IO.Stream.WriteAsync(), and System.Security.Cryptography.CryptographicOperations.ZeroMemory().

Referenced by System.Security.Cryptography.CryptoStream.Write(), and System.Security.Cryptography.CryptoStream.WriteAsyncInternal().