---

This section details on the original issue you should resolve

<issue_title>FromBase64Transform incorrectly rents from CryptoPool (ArrayPool)</issue_title>
<issue_description>### Description

FromBase64Transform, when given a partial block, will retain the block and keep it around for the next transform so that it can transform a complete block. That happens here:

runtime/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Base64Transforms.cs

Lines 165 to 166 in ec72407

	// Too little data to decode: save data to _inputBuffer, so it can be transformed later
	if (bytesToTransform < InputBlockSize)

On the next call to TransformBlock, it will take the retained input and combine it with the input to the transformed data. In order to do this, it creates a contiguous buffer and combines them. It does this on the stack if the buffer is small enough, otherwise it rents from CryptoPool (a veneer over ArrayPool).

However, when it rents from the CryptoPool, it does not account for the retained buffer. This means that if the second call to TransformBlock is within three bytes of a power of two, the rented buffer won't be large enough to complete the copy. That rent happens here:

runtime/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/Base64Transforms.cs

Line 158 in ec72407

transformBuffer = transformBufferArray = CryptoPool.Rent(inputCount);

Note that it is renting inputCount, not bytesToTransform.

This likely "works" in a lot of scenarios because usually the amount rented from the ArrayPool is oversized. This can only be hit when:

1. There are N number of byte retained in _inputIndex
2. The next transform is within N number of bytes of a power of two that hits the rental size boundary.

Reproduction Steps

using System;
using System.Diagnostics;
using System.Security.Cryptography;

FromBase64Transform transform = new();
byte[] dest = new byte[2048];

byte[] buf1 = "AAA"u8.ToArray();
int written = transform.TransformBlock(buf1, 0, 3, dest, 0);

// Nothing should be written because it is a partial block the transform will hold on to.
Debug.Assert(written == 0);

// Transform a buffer that is exactly a power of two, meaning the ArrayPool (CryptoPool) will not be oversized.
byte[] buf2 = new byte[1024];
buf2.AsSpan().Fill((byte)'A');

written = transform.TransformBlock(buf2, 0, buf2.Length, dest, written);

Expected behavior

Should not throw an exception. Should transform as many blocks as possible to the destination.

Actual behavior

Unhandled exception. System.ArgumentException: Destination is too short. (Parameter 'destination')
   at System.Security.Cryptography.FromBase64Transform.AppendInputBuffers(ReadOnlySpan`1 inputBuffer, Span`1 transformBuffer)
   at System.Security.Cryptography.FromBase64Transform.TransformBlock(Byte[] inputBuffer, Int32 inputOffset, Int32 inputCount, Byte[] outputBuffer, Int32 outputOffset)
   at Program.<Main>$(String[] args) in /Users/vcsjones/Projects/scratch/Program.cs:line 18

Regression?

Unknown, but the code hasn't changed much since 2023.

Known Workarounds

Work around the rental boundaries.

Configuration

All configurations and OSes.

Other information

No response</issue_description>

Comments on the Issue (you are @copilot in this section)