Constant stackalloc can be optimized by the JIT.

dotnet/runtime#54186 (comment)

src/JsonWebToken/Base64.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Buffers;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
 
 namespace JsonWebToken
@@ -46,7 +47,7 @@ public static int Decode(ReadOnlySpan<char> base64, Span<byte> data)
             byte[]? arrayToReturn = null;
             var buffer = base64.Length > Constants.MaxStackallocBytes
                 ? (arrayToReturn = ArrayPool<byte>.Shared.Rent(base64.Length))
-                : stackalloc byte[base64.Length];
+                : stackalloc byte[Constants.MaxStackallocBytes];
             try
             {
                 int length = Utf8.GetBytes(base64, buffer);
@@ -83,7 +84,7 @@ public static OperationStatus Decode(ReadOnlySpan<byte> base64, Span<byte> data,
                 byte[]? utf8ArrayToReturn = null;
                 Span<byte> utf8Data = base64.Length > Constants.MaxStackallocBytes
                     ? (utf8ArrayToReturn = ArrayPool<byte>.Shared.Rent(base64.Length))
-                    : stackalloc byte[base64.Length];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
                 try
                 {
                     int length = 0;
@@ -118,7 +119,7 @@ public static OperationStatus Decode(ReadOnlySpan<byte> base64, Span<byte> data,
             }
         }
 
-        private static bool IsWhiteSpace(byte c) 
+        private static bool IsWhiteSpace(byte c)
             => c == ' ' || (c >= '\t' && c <= '\r');
 
         private static ReadOnlySpan<byte> WhiteSpace => new byte[] { (byte)' ', (byte)'\t', (byte)'\r', (byte)'\n', (byte)'\v', (byte)'\f' };
@@ -173,7 +174,7 @@ public static byte[] Encode(ReadOnlySpan<char> data)
                 int length = Utf8.GetMaxByteCount(data.Length);
                 var utf8Data = length > Constants.MaxStackallocBytes
                     ? (utf8ArrayToReturn = ArrayPool<byte>.Shared.Rent(length))
-                    : stackalloc byte[length];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
 
                 int written = Utf8.GetBytes(data, utf8Data);
                 return Encode(utf8Data.Slice(0, written));

src/JsonWebToken/Base64Url.cs

@@ -26,7 +26,7 @@ public static byte[] Decode(string data)
             {
                 Span<byte> tmp = length > Constants.MaxStackallocBytes
                     ? (utf8ArrayToReturn = ArrayPool<byte>.Shared.Rent(length))
-                    : stackalloc byte[length];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
                 int written = Utf8.GetBytes(data, tmp);
                 return Decode(tmp.Slice(0, written));
             }
@@ -70,7 +70,7 @@ public static int Decode(ReadOnlySpan<char> base64Url, Span<byte> data)
             byte[]? arrayToReturn = null;
             var buffer = base64Url.Length > Constants.MaxStackallocBytes
                 ? (arrayToReturn = ArrayPool<byte>.Shared.Rent(base64Url.Length))
-                : stackalloc byte[base64Url.Length];
+                : stackalloc byte[Constants.MaxStackallocBytes];
             try
             {
                 int length = Utf8.GetBytes(base64Url, buffer);
@@ -163,7 +163,7 @@ public static byte[] Encode(ReadOnlySpan<char> data)
                 int length = Utf8.GetMaxByteCount(data.Length);
                 var utf8Data = length > Constants.MaxStackallocBytes
                     ? (utf8ArrayToReturn = ArrayPool<byte>.Shared.Rent(length))
-                    : stackalloc byte[length];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
 
                 int written = Utf8.GetBytes(data, utf8Data);
                 return Encode(utf8Data.Slice(0, written));

src/JsonWebToken/Cryptography/AesCbcHmacDecryptor.cs

@@ -75,10 +75,11 @@ private bool VerifyAuthenticationTag(ReadOnlySpan<byte> key, ReadOnlySpan<byte>
             byte[]? byteArrayToReturnToPool = null;
             int macLength = associatedData.Length + iv.Length + ciphertext.Length + sizeof(long);
             Span<byte> macBytes = macLength <= Constants.MaxStackallocBytes
-                                    ? stackalloc byte[macLength]
-                                    : (byteArrayToReturnToPool = ArrayPool<byte>.Shared.Rent(macLength)).AsSpan(0, macLength);
+                                    ? stackalloc byte[Constants.MaxStackallocBytes]
+                                    : (byteArrayToReturnToPool = ArrayPool<byte>.Shared.Rent(macLength));
             try
             {
+                macBytes = macBytes.Slice(0, macLength);
                 associatedData.CopyTo(macBytes);
                 var bytes = macBytes.Slice(associatedData.Length);
                 iv.CopyTo(bytes);
@@ -88,9 +89,9 @@ private bool VerifyAuthenticationTag(ReadOnlySpan<byte> key, ReadOnlySpan<byte>
                 BinaryPrimitives.WriteInt64BigEndian(bytes, associatedData.Length << 3);
 
                 Sha2 hashAlgorithm = _encryptionAlgorithm.SignatureAlgorithm.Sha;
-                Span<byte> hmacKey = stackalloc byte[hashAlgorithm.BlockSize * 2];
+                Span<byte> hmacKey = stackalloc byte[Sha2.BlockSizeStackallocThreshold * 2].Slice(0, hashAlgorithm.BlockSize * 2); 
                 Hmac hmac = new Hmac(hashAlgorithm, key, hmacKey);
-                Span<byte> hash = stackalloc byte[authenticationTag.Length * 2];
+                Span<byte> hash = stackalloc byte[AuthenticatedEncryptor.TagSizeStackallocThreshold].Slice(0, authenticationTag.Length * 2);
                 hmac.ComputeHash(macBytes, hash);
                 CryptographicOperations.ZeroMemory(hmacKey);
 

src/JsonWebToken/Cryptography/AesCbcHmacEncryptor.cs

@@ -90,8 +90,8 @@ private void ComputeAuthenticationTag(ReadOnlySpan<byte> key, ReadOnlySpan<byte>
             {
                 int macLength = associatedData.Length + iv.Length + ciphertext.Length + sizeof(long);
                 Span<byte> macBytes = macLength <= Constants.MaxStackallocBytes
-                    ? stackalloc byte[macLength]
-                    : (arrayToReturnToPool = ArrayPool<byte>.Shared.Rent(macLength)).AsSpan(0, macLength);
+                    ? stackalloc byte[Constants.MaxStackallocBytes]
+                    : (arrayToReturnToPool = ArrayPool<byte>.Shared.Rent(macLength));
 
                 associatedData.CopyTo(macBytes);
                 var bytes = macBytes.Slice(associatedData.Length);
@@ -102,9 +102,9 @@ private void ComputeAuthenticationTag(ReadOnlySpan<byte> key, ReadOnlySpan<byte>
                 BinaryPrimitives.WriteInt64BigEndian(bytes, associatedData.Length << 3);
 
                 Sha2 hashAlgorithm = _encryptionAlgorithm.SignatureAlgorithm.Sha;
-                Span<byte> hmacKey = stackalloc byte[hashAlgorithm.BlockSize * 2];
-                Hmac hmac = new Hmac(hashAlgorithm, key, hmacKey);
-                hmac.ComputeHash(macBytes, authenticationTag);
+                Span<byte> hmacKey = stackalloc byte[Sha2.BlockSizeStackallocThreshold * 2];
+                Hmac hmac = new Hmac(hashAlgorithm, key, hmacKey.Slice(0, hashAlgorithm.BlockSize * 2));
+                hmac.ComputeHash(macBytes.Slice(0, macLength), authenticationTag);
                 authenticationTagBytesWritten = authenticationTag.Length >> 1;
             }
             finally

src/JsonWebToken/Cryptography/AesGcmKeyUnwrapper.cs

@@ -10,6 +10,9 @@ namespace JsonWebToken.Cryptography
 {
     internal sealed class AesGcmKeyUnwrapper : KeyUnwrapper
     {
+        private const int IVSize = 12;
+        private const int TagSize = 16;
+
         private readonly SymmetricJwk _key;
 
         public AesGcmKeyUnwrapper(SymmetricJwk key, EncryptionAlgorithm encryptionAlgorithm, KeyManagementAlgorithm algorithm)
@@ -38,9 +41,9 @@ public override bool TryUnwrapKey(ReadOnlySpan<byte> keyBytes, Span<byte> destin
             }
 
             var rawIV = encodedIV.GetRawValue();
-            Span<byte> nonce = stackalloc byte[Base64Url.GetArraySizeRequiredToDecode(rawIV.Length)];
+            Span<byte> nonce = stackalloc byte[IVSize];
             var rawTag = encodedTag.GetRawValue();
-            Span<byte> tag = stackalloc byte[Base64Url.GetArraySizeRequiredToDecode(rawTag.Length)];
+            Span<byte> tag = stackalloc byte[TagSize];
             try
             {
                 Base64Url.Decode(rawIV.Span, nonce);

src/JsonWebToken/Cryptography/AesKeyUnwrapper.cs

@@ -12,6 +12,7 @@ namespace JsonWebToken.Cryptography
     internal sealed class AesKeyUnwrapper : KeyUnwrapper
     {
         private const int BlockSizeInBytes = 8;
+        private const int KeyWrappedSizeThreshold = 64;
 
         // The default initialization vector from RFC3394
         private const ulong _defaultIV = 0XA6A6A6A6A6A6A6A6;
@@ -85,7 +86,7 @@ public override bool TryUnwrapKey(ReadOnlySpan<byte> key, Span<byte> destination
             int n = key.Length - BlockSizeInBytes;
 
             // The set of input blocks
-            Span<byte> r = stackalloc byte[n];
+            Span<byte> r = stackalloc byte[KeyWrappedSizeThreshold].Slice(0, n);
             r.Clear();
             ref byte rRef = ref MemoryMarshal.GetReference(r);
             Unsafe.CopyBlockUnaligned(ref rRef, ref Unsafe.AddByteOffset(ref input, (IntPtr)8), (uint)n);

src/JsonWebToken/Cryptography/AesKeyWrapper.cs

@@ -12,6 +12,7 @@ namespace JsonWebToken.Cryptography
     internal sealed class AesKeyWrapper : KeyWrapper
     {
         private const int BlockSizeInBytes = 8;
+        private const int KeyWrappedSizeThreshold = 64;
 
         // The default initialization vector from RFC3394
         private const ulong _defaultIV = 0XA6A6A6A6A6A6A6A6;
@@ -84,7 +85,7 @@ public override SymmetricJwk WrapKey(Jwk? staticKey, JwtHeader header, Span<byte
 
             ulong a = _defaultIV;
             ref byte input = ref MemoryMarshal.GetReference(inputBuffer);
-            Span<byte> r = stackalloc byte[n];
+            Span<byte> r = stackalloc byte[KeyWrappedSizeThreshold].Slice(0, n);
             ref byte rRef = ref MemoryMarshal.GetReference(r);
             Unsafe.CopyBlockUnaligned(ref rRef, ref input, (uint)n);
             TryWrapKey(ref a, n, ref rRef);

src/JsonWebToken/Cryptography/AuthenticatedEncryptor.cs

@@ -30,5 +30,9 @@ public abstract class AuthenticatedEncryptor
 
         /// <summary>Gets the required size of the base64-URL nonce.</summary>
         public abstract int GetBase64NonceSize();
+
+        internal const int TagSizeStackallocThreshold = 64;
+
+        internal const int NonceSizeStackallocThreshold = 16;
     }
 }

src/JsonWebToken/Cryptography/EcdsaSignatureVerifier.cs

@@ -50,7 +50,7 @@ public override bool Verify(ReadOnlySpan<byte> data, ReadOnlySpan<byte> signatur
 
             var ecdsa = _ecdsaPool.Get();
 #if SUPPORT_SPAN_CRYPTO
-            Span<byte> hash = stackalloc byte[_sha.HashSize];
+            Span<byte> hash = stackalloc byte[Sha2.BlockSizeStackallocThreshold].Slice(0, _sha.HashSize);
             _sha.ComputeHash(data, hash);
             return ecdsa.VerifyHash(hash, signature);
 #else

src/JsonWebToken/Cryptography/EcdsaSigner.cs

@@ -45,7 +45,7 @@ public override bool TrySign(ReadOnlySpan<byte> data, Span<byte> destination, ou
 
             var ecdsa = _ecdsaPool.Get();
 #if SUPPORT_SPAN_CRYPTO
-            Span<byte> hash = stackalloc byte[_sha.HashSize];
+            Span<byte> hash = stackalloc byte[Sha2.BlockSizeStackallocThreshold].Slice(0, _sha.HashSize);
             _sha.ComputeHash(data, hash);
             return ecdsa.TrySignHash(hash, destination, out bytesWritten);
 #else

src/JsonWebToken/Cryptography/Hmac.cs

@@ -25,14 +25,14 @@ internal readonly ref struct Hmac
         public Hmac(Sha2 sha2, ReadOnlySpan<byte> key, Span<byte> hmacKey)
         {
             Debug.Assert(sha2 != null);
-            Debug.Assert(hmacKey.Length == sha2!.BlockSize * 2);
+            Debug.Assert(hmacKey.Length >= sha2.BlockSize * 2);
 
             Sha2 = sha2;
             _keys = hmacKey;
             int blockSize = sha2.BlockSize;
             if (key.Length > blockSize)
             {
-                Span<byte> keyPrime = stackalloc byte[blockSize];
+                Span<byte> keyPrime = stackalloc byte[Sha2.BlockSizeStackallocThreshold * 2].Slice(0, blockSize);
                 HmacHelper.InitializeIOKeys(keyPrime, _keys, blockSize);
                 keyPrime.Clear();
             }
@@ -53,7 +53,7 @@ public void ComputeHash(ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 Span<byte> W = size > Constants.MaxStackallocBytes
                     ? (arrayToReturn = ArrayPool<byte>.Shared.Rent(size))
-                    : stackalloc byte[size];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
                 Sha2.ComputeHash(source, _keys.Slice(0, blockSize), destination, W);
                 Sha2.ComputeHash(destination, _keys.Slice(blockSize, blockSize), destination, W);
             }

src/JsonWebToken/Cryptography/HmacSha2.cs

@@ -40,7 +40,7 @@ public HmacSha2(Sha2 sha2, ReadOnlySpan<byte> key)
             _outerPadKey = new ReadOnlyMemory<byte>(_keys, blockSize, blockSize);
             if (key.Length > blockSize)
             {
-                Span<byte> keyPrime = stackalloc byte[sha2.HashSize];
+                Span<byte> keyPrime = stackalloc byte[Sha2.HashSizeStackallocThreshold].Slice(0, sha2.HashSize);
                 Sha2.ComputeHash(key, default, keyPrime, default);
                 HmacHelper.InitializeIOKeys(keyPrime, _keys, blockSize);
                 keyPrime.Clear();
@@ -61,7 +61,7 @@ public void ComputeHash(ReadOnlySpan<byte> source, Span<byte> destination)
             {
                 Span<byte> W = size > Constants.MaxStackallocBytes
                     ? (arrayToReturn = ArrayPool<byte>.Shared.Rent(size))
-                    : stackalloc byte[size];
+                    : stackalloc byte[Constants.MaxStackallocBytes];
                 Sha2.ComputeHash(source, _innerPadKey.Span, destination, W);
                 Sha2.ComputeHash(destination, _outerPadKey.Span, destination, W);
             }

src/JsonWebToken/Cryptography/KeyWrapper.cs

@@ -53,5 +53,7 @@ public void Dispose()
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static SymmetricJwk CreateSymmetricKey(EncryptionAlgorithm encryptionAlgorithm, SymmetricJwk? staticKey)
             => staticKey ?? SymmetricJwk.GenerateKey(encryptionAlgorithm.RequiredKeySizeInBits, computeThumbprint: false);
+
+        internal const int WrappedKeySizeStackallocThreshold = 72;
     }
 }

src/JsonWebToken/Cryptography/Pbes2KeyUnwrapper.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT license. See LICENSE in the project root for license information.
 
 using System;
+using System.Buffers;
 using System.Diagnostics;
 using System.Security.Cryptography;
 using System.Text.Json;
@@ -10,6 +11,8 @@ namespace JsonWebToken.Cryptography
 {
     internal sealed class Pbes2KeyUnwrapper : KeyUnwrapper
     {
+        private const int KeySizeThreshold = 32;
+
         private readonly JsonEncodedText _algorithm;
         private readonly int _algorithmNameLength;
         private readonly int _keySizeInBytes;
@@ -53,18 +56,32 @@ public override bool TryUnwrapKey(ReadOnlySpan<byte> keyBytes, Span<byte> destin
             int iterationCount = (int)p2c.GetInt64();
             var b64p2s = p2s.GetRawValue();
             int p2sLength = Base64Url.GetArraySizeRequiredToDecode(b64p2s.Length);
+
+            int saltLength = p2sLength + 1 + _algorithmNameLength;
+            byte[]? saltArray = null;
+            Span<byte> salt = saltLength <= Pbkdf2.SaltSizeThreshold + 18 + 1
+                                ? stackalloc byte[Pbkdf2.SaltSizeThreshold + 18 + 1]
+                                : (saltArray = ArrayPool<byte>.Shared.Rent(saltLength));
+            try
+            {
+                salt = salt.Slice(0, saltLength);
+                Base64Url.Decode(b64p2s.Span, salt.Slice(_algorithmNameLength + 1));
+                salt[_algorithmNameLength] = 0x00;
+                _algorithm.EncodedUtf8Bytes.CopyTo(salt);
 
+                Span<byte> derivedKey = stackalloc byte[KeySizeThreshold].Slice(0, _keySizeInBytes);
+                Pbkdf2.DeriveKey(_password, salt, _hashAlgorithm, (uint)iterationCount, derivedKey);
 
-            Span<byte> salt = stackalloc byte[p2sLength + 1 + _algorithmNameLength];
-            Base64Url.Decode(b64p2s.Span, salt.Slice(_algorithmNameLength + 1));
-            salt[_algorithmNameLength] = 0x00;
-            _algorithm.EncodedUtf8Bytes.CopyTo(salt);
-
-            Span<byte> derivedKey = stackalloc byte[_keySizeInBytes];
-            Pbkdf2.DeriveKey(_password, salt, _hashAlgorithm, (uint)iterationCount, derivedKey);
-
-            using var keyUnwrapper = new AesKeyUnwrapper(derivedKey, EncryptionAlgorithm, _keyManagementAlgorithm);
-            return keyUnwrapper.TryUnwrapKey(keyBytes, destination, header, out bytesWritten);
+                using var keyUnwrapper = new AesKeyUnwrapper(derivedKey, EncryptionAlgorithm, _keyManagementAlgorithm);
+                return keyUnwrapper.TryUnwrapKey(keyBytes, destination, header, out bytesWritten);
+            }
+            finally
+            {
+                if (saltArray != null)
+                {
+                    ArrayPool<byte>.Shared.Return(saltArray);
+                }
+            }
         }
 
         protected override void Dispose(bool disposing)