104080 custom rsapss salt length by henning-krause · Pull Request #119255 · dotnet/runtime

henning-krause · 2025-09-02T05:45:50Z

Added support for custom PSS salt length for RSA based signature operations. Resolves #104080.

With this PR, I have extended the RsaSignaturePadding class with a custom salt length as discussed in #104080. I've also updated the CmsSigner and the CertificateRequest class to support this.

CoseSigner did not need functionality updates, because the spec does not support custom salt length. I have added checks to prevent this to be configured on the CoseSigner.

Tests where either added or updated to test the new functionality.

All RSA implementations which support this (MAC doesn't seem to support this) were updated.

…ation/generation with RSA keys. dotnet#104080

…lt customizations

…pported there) Updated reference code

Cose does not support custom salt lengths with PSS.

Copilot

Pull Request Overview

This pull request adds support for custom PSS salt length for RSA-based signature operations. The implementation extends the RSASignaturePadding class with a new CreatePss(int saltLength) method and updates related cryptographic components to utilize custom salt lengths.

Key changes include:

Extended RSASignaturePadding to support custom PSS salt lengths with new constants and factory method
Updated all RSA implementation backends (OpenSSL, CNG, BCrypt, etc.) to handle custom salt lengths
Added comprehensive test coverage for various salt length scenarios
Updated high-level APIs like CmsSigner and CertificateRequest to support the new functionality

Reviewed Changes

Copilot reviewed 40 out of 41 changed files in this pull request and generated 5 comments.

Show a summary per file

File	Description
src/native/libs/System.Security.Cryptography.Native/pal_evp_pkey_rsa.h	Added pssSaltLength parameter to RSA sign/verify functions
src/native/libs/System.Security.Cryptography.Native/pal_evp_pkey_rsa.c	Implemented custom salt length support in OpenSSL backend
src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/RSASignaturePadding.cs	Added CreatePss method, PssSaltLength property, and related constants
src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/X509Certificates/RSAPssX509SignatureGenerator.cs	Updated to use custom salt lengths from padding configuration
src/libraries/Common/src/System/Security/Cryptography/RsaPaddingProcessor.cs	Modified PSS encoding/verification to accept custom salt lengths
src/libraries/Common/src/System/Security/Cryptography/RsaPaddingProcessor.DigestInfo.cs	Added salt length calculation logic and moved digest info constants
src/libraries/System.Security.Cryptography/tests/X509Certificates/CertificateCreation/RSAPssX509SignatureGeneratorTests.cs	Added comprehensive tests for custom PSS salt lengths
src/libraries/System.Security.Cryptography.Pkcs/src/System/Security/Cryptography/Pkcs/CmsSigner.cs	Updated validation to accept any PSS mode padding
src/libraries/System.Security.Cryptography.Cose/src/System/Security/Cryptography/Cose/CoseSigner.cs	Added validation to prevent custom salt lengths in COSE

…tes/CertificateCreation/CertificateRequestChainTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

….Cryptography.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

…ngProcessor.DigestInfo.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 4 comments.

Comments suppressed due to low confidence (1)

src/libraries/System.Security.Cryptography/tests/X509Certificates/CertificateCreation/RSAPssX509SignatureGeneratorTests.cs:1

In RSASSA-PSS-params, saltLength is [2] INTEGER (implicitly-tagged), which is encoded as a context-specific primitive integer, not a constructed sequence. Creating the tag as constructed (..., true) and calling ReadSequence(saltTag) is therefore incorrect and should fail to parse on correctly-encoded inputs. Use a primitive context-specific tag and read it as an integer with the expected tag (e.g., via an AsnReader.ReadInteger(expectedTag) overload) rather than reading a sequence.

bartonjs · 2026-06-18T18:21:41Z

+            {
+#if NET11_0_OR_GREATER
+                if (SignaturePadding.PssSaltLength != RSASignaturePadding.PssSaltLengthIsHashLength)
+                {
+                    signatureParameters = GetSignaturePaddingForCustomPssSaltLength(publicKey, hashAlgorithmName);
+                }
+#endif
+                if (hashAlgorithmName == HashAlgorithmName.SHA1)
+                {
+                    signatureParameters = s_rsaPssSha1Parameters;
+                }
+                else if (hashAlgorithmName == HashAlgorithmName.SHA256)
+                {


This may be what is causing tests to fail.

bartonjs · 2026-06-18T18:05:47Z

@@ -531,9 +546,9 @@ public override bool VerifyHash(ReadOnlySpan<byte> hash, ReadOnlySpan<byte> sign
                        Debug.Fail($"TryRsaVerificationPrimitive with a pre-allocated buffer");
                        throw new CryptographicException();
                    }


The prevailing style here is a blank line after } unless followed by }, not sure why this line got deleted.

Suggested change

}

}

bartonjs · 2026-06-18T18:07:28Z

                // 11. Set the "unused" bits in the leftmost byte of maskedDB to 0.
                int unusedBits = 8 * emLen - emBits;
-
                if (unusedBits != 0)


The prevailing style is a blank line (or {) before a control flow statement. Not sure why this line got deleted.

Suggested change

if (unusedBits != 0)

if (unusedBits != 0)

bartonjs · 2026-06-18T18:08:06Z

+        }
+
+    }


Suggested change

}

}

}

}

bartonjs · 2026-06-18T18:10:28Z

+
+                foreach (var saltLength in saltLengths)
+                {
+                    var padding = saltLength is null ? RSASignaturePadding.Pss : RSASignaturePadding.CreatePss(saltLength.Value);


Suggested change

var padding = saltLength is null ? RSASignaturePadding.Pss : RSASignaturePadding.CreatePss(saltLength.Value);

RSASignaturePadding padding = saltLength is null ?

RSASignaturePadding.Pss :

RSASignaturePadding.CreatePss(saltLength.Value);

bartonjs · 2026-06-18T19:29:46Z


                // Assert.NoThrow
-                CertificateRequest.LoadSigningRequest(pkcs10, hashAlgorithmName, out _);
+                CertificateRequest.LoadSigningRequest(pkcs10, hashAlgorithmName, out _, signerSignaturePadding: padding);


Is this edit necessary? The only thing the optional RSASignaturePadding should do is control how a future CreateSigningRequest, CreateSelfSigned, or Create works. It being null here should be allowed in the cases it was in the past...

bartonjs · 2026-06-18T19:32:57Z

-                pssStructure.ReadEncodedValue(); // Ignore the hash algorithm OID
-                pssStructure.ReadEncodedValue(); // Ignore the mask generation function OID
+                ReadOnlyMemory<byte> hashAlgorithm = pssStructure.ReadEncodedValue(); // Ignore the hash algorithm OID
+                ReadOnlyMemory<byte> mgf = pssStructure.ReadEncodedValue(); // Ignore the mask generation function OID


I still don't see the mgf or hashAlgorithm values being verified in this routine?

bartonjs · 2026-06-18T19:34:44Z

+                    // Salt length is 234
+                    return "303606092a864886f70d01010a3029a009300706052b0e03021aa116301406092a864886f70d010108300706052b0e03021aa204020200ea".HexToByteArray();
+                }
+            }


Suggested change

}

}

bartonjs · 2026-06-18T21:40:44Z

+                0x11, 0xf2, 0x10, 0xbd, 0x19, 0x47, 0x75, 0x3c, 0x30, 0xc4, 0x0f, 0xd0, 0x7b, 0xc2, 0x6b, 0x4b
+            };
+
+            RSASignaturePadding padding = RSASignaturePadding.CreatePss(validateWithCorrectSaltLength ? RSASignaturePadding.PssSaltLengthMax : 2);


I'd like to see two tests added to show that the sentinel values aren't special (aside from in COSE), something like

[Theory] [InlineData("SHA256", 256 / 8)] [InlineData("SHA384", 384 / 8)] public void PssWithImplicitAndExplicitHashLength(string hashName, int hashLength) { byte[] data = TestData.HelloBytes; HashAlgorithmName hashAlg = new HashAlgorithmName(hashName); RSASignaturePadding implicitPadding = RSASignaturePadding.Pss; RSASignaturePadding explicitPadding = RSASignaturePadding.CreatePSS(hashLength); using (RSA rsa = RSAFactory.Create(TestData.RSA2048Params)) { byte[] implicitSig = rsa.SignData(data, hashAlg, implicitPadding); byte[] explicitSig = rsa.SignData(data, hashAlg, explicitPadding); AssertExtensions.TrueExpression(rsa.VerifyData(data, implicitSig, hashAlg, explicitPadding)); AssertExtensions.TrueExpression(rsa.VerifyData(data, explicitSig, hashAlg, implicitPadding)); if (custom pss is supported) { RSASignaturePadding minusOne = RSASignaturePadding.CreatePSS(hashLength - 1); RSASignaturePadding plusOne = RSASignaturePadding.CreatePSS(hashLength + 1); AssertExtensions.FalseExpression(rsa.VerifyData(data, implicitSig, hashAlg, minusOne)); AssertExtensions.FalseExpression(rsa.VerifyData(data, implicitSig, hashAlg, plusOne)); } } }

and a similar test for max-length padding, though it needs to vary on the keysize/max.

bartonjs · 2026-06-18T21:43:58Z

+                }
+            }
+        }
+


Is there a test that I'm not immediately seeing that shows that calling Sign with a PSS padding sLen too large throws a reasonable exception? And one that shows that calling verify with that same sLen returns false instead of throw? (The desired PssWithMaxAndExplicitHashLength test would (ideally) have a redundant sLen > sLenMax test, but there should be a dedicated one.)

…thmImplementations/RSA/SignVerify.cs Co-authored-by: Jeremy Barton <jbarton@microsoft.com>

Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 4 comments.

+#if NET11_0_OR_GREATER
+                if (SignaturePadding.PssSaltLength != RSASignaturePadding.PssSaltLengthIsHashLength)
+                {
+                    signatureParameters = GetSignaturePaddingForCustomPssSaltLength(publicKey, hashAlgorithmName);
+                }
+#endif


+#if NET11_0_OR_GREATER
+            if (signaturePadding.Mode == RSASignaturePaddingMode.Pss)
+            {
+                if (signaturePadding.PssSaltLength != RSASignaturePadding.PssSaltLengthIsHashLength)
+                {
+                    throw new ArgumentException(SR.CoseSignerPssSaltLengthMustBeHashLength, nameof(signaturePadding));
+                }
+            }
+#endif


+#if NET11_0_OR_GREATER
+                Debug.Assert(signaturePadding.PssSaltLength == RSASignaturePadding.PssSaltLengthIsHashLength);
+#endif


+#if NET11_0_OR_GREATER
+            return RSASignaturePadding.CreatePss(SaltLength);
+#else


…salt-length

…/henning-krause/runtime into 104080-custom-rsapss-salt-length

Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 1 comment.

Comments suppressed due to low confidence (2)

src/libraries/Common/src/System/Security/Cryptography/RsaPaddingProcessor.cs:300

The size check if (emLen < 2 + hLen + sLen) can overflow when sLen is a large user-supplied value (via CreatePss), which can bypass the guard and lead to large allocations/invalid slicing later. Use subtraction (or long/checked arithmetic) to make the guard overflow-safe.

            // 3.  if emLen < hLen + sLen + 2, encoding error.
            //
            // sLen = hLen in this implementation.

            if (emLen < 2 + hLen + sLen)

src/libraries/Common/src/System/Security/Cryptography/RsaPaddingProcessor.cs:393

This guard uses hLen + sLen + 2, which can overflow for large sLen values and incorrectly skip returning false. That can result in negative indexes later in VerifyPss. Make the check overflow-safe (e.g., via subtraction) before proceeding.

            // 3. If emLen < hLen + sLen + 2, output "inconsistent" and stop.
            if (emLen < hLen + sLen + 2)
            {
                return false;
            }

            {
-                Debug.Assert(padding == RSASignaturePadding.Pss);
+                // PSS salt length is validated in the RsaSignaturePaddingMode constructor.
+                Debug.Assert(padding.PssSaltLength >= RSASignaturePadding.PssSaltLengthMax);
            }


Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 1 comment.

+                Numerics.BigInteger actualSaltLength = saltEntry.ReadInteger();
+                int expectedSaltLength = saltLengthToTest switch
+                {
+                    RSASignaturePadding.PssSaltLengthIsHashLength => hashLength,
+                    RSASignaturePadding.PssSaltLengthMax => maxSaltLength,
+                    _ => saltLengthToTest,
+                };
+                Assert.Equal(expectedSaltLength, actualSaltLength);


…salt-length

Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 3 comments.

+            private static void ValidatePaddingParameters(HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
+            {
+                // Apple does not support custom salt length for the PSS padding
+                if (padding.Mode == RSASignaturePaddingMode.Pss &&
+                    (padding.PssSaltLength != RSASignaturePadding.PssSaltLengthIsHashLength &&
+                    padding.PssSaltLength != RsaPaddingProcessor.HashLength(hashAlgorithm)))
+                {
+                    throw new CryptographicException(SR.Cryptography_CustomPssSaltLengthNotSupported);
+                }
+            }


+            using (RSA rsa = RSA.Create())
+            {
+                var requestBuilder = new CertificateRequest("CN=Test", rsa, HashAlgorithmName.SHA256, RSASignaturePadding.CreatePss(customSaltLength));
+                X509Certificate2 cert = requestBuilder.CreateSelfSigned(DateTime.Now, DateTime.Now.AddYears(1));
+
+                var reader = new AsnReader(cert.RawData, AsnEncodingRules.DER);
+                AsnReader sequence = reader.ReadSequence();
+                ReadOnlyMemory<byte> tbsCertificate = sequence.ReadEncodedValue();
+                ReadOnlyMemory<byte> signatureAlgorithm = sequence.ReadEncodedValue();
+                byte[] signature = sequence.ReadBitString(out _);
+
+                int testSaltLength = customSaltLength switch
+                {
+                    RSASignaturePadding.PssSaltLengthMax => 222,
+                    RSASignaturePadding.PssSaltLengthIsHashLength => 32,
+                    _ => customSaltLength
+                };
+                Assert.True(rsa.VerifyData(tbsCertificate.Span, signature, HashAlgorithmName.SHA256, RSASignaturePadding.CreatePss(testSaltLength)));
+            }


            if (hashAlgorithm == HashAlgorithmName.SHA1)
-                return "300D06092A864886F70D01010A3000".HexToByteArray();
-
+            {
+                if (_signaturePadding.PssSaltLength == RSASignaturePadding.PssSaltLengthIsHashLength)
+                {
+                    // sha1WithRSAEncryption with RSASSA-PSS parameters
+                    return "300D06092A864886F70D01010A3000".HexToByteArray();
+                }
+                else if (_signaturePadding.PssSaltLength == 0)
+                {
+                    return "303506092a864886f70d01010a3028a009300706052b0e03021aa116301406092a864886f70d010108300706052b0e03021aa203020100".HexToByteArray();
+                }
+                else if (_signaturePadding.PssSaltLength == 1)
+                {
+                    return "303506092a864886f70d01010a3028a009300706052b0e03021aa116301406092a864886f70d010108300706052b0e03021aa203020101".HexToByteArray();
+                }
+                else if (_signaturePadding.PssSaltLength == RSASignaturePadding.PssSaltLengthMax)
+                {
+                    // Salt length is 234
+                    return "303606092a864886f70d01010a3029a009300706052b0e03021aa116301406092a864886f70d010108300706052b0e03021aa204020200ea".HexToByteArray();
+                }


henning-krause · 2026-07-15T13:08:56Z

@bartonjs All comments should now be fixed... Can you review my last changes? Thanks :-)

Copilot

Pull request overview

Copilot reviewed 38 out of 39 changed files in this pull request and generated 2 comments.

+        /// <summary>
+        /// Specifies the salt length to use for PSS padding. This property is only relevant when the <see cref="Mode"/> is <see cref="RSASignaturePaddingMode.Pss"/>.
+        /// </summary>
+        /// <remarks>
+        /// This value must either be a non-negative number or one of the special constants <see cref="PssSaltLengthIsHashLength"/> or <see cref="PssSaltLengthMax"/>.
+        /// </remarks>
+        public int PssSaltLength { get; }


            {
-                Debug.Assert(padding == RSASignaturePadding.Pss);
+                // PSS salt length is validated in the RsaSignaturePaddingMode constructor.
+                Debug.Assert(padding.PssSaltLength >= RSASignaturePadding.PssSaltLengthMax);


github-actions · 2026-07-19T11:18:21Z

Workflow state for the Holistic Review Orchestrator.

{
  "version": 5,
  "last_dispatched_commit": "d0d88a24fb7edde8e3b0826d606d91309e18ef35",
  "last_dispatched_base_ref": "main",
  "last_dispatched_base_sha": "17bbb207a46d1b2ae3741baa62cb88a98e2e9847",
  "last_reviewed_commit": "d0d88a24fb7edde8e3b0826d606d91309e18ef35",
  "last_reviewed_base_ref": "main",
  "last_reviewed_base_sha": "17bbb207a46d1b2ae3741baa62cb88a98e2e9847",
  "last_recorded_worker_run_id": "29684886999",
  "review_attempt_commit": "",
  "review_attempt_base_ref": "",
  "review_attempt_count": 0,
  "max_review_attempts": 5,
  "review_history_format": "holistic-review-disclosure-v1",
  "review_history": [
    {
      "commit": "d0d88a24fb7edde8e3b0826d606d91309e18ef35",
      "review_id": 4730678743
    }
  ]
}

github-actions

Holistic Review

Motivation: Justified. Issue #104080 is api-approved and documents a real interoperability gap: .NET hard-codes the PSS salt length to the hash length, so it cannot produce or validate PSS signatures that use a different salt length (e.g. RSA_PSS_SALTLEN_MAX or an explicit value), which other stacks and standards require.

Approach: Sound and consistent with the codebase. RSASignaturePadding.CreatePss(int) plus the PssSaltLengthIsHashLength/PssSaltLengthMax sentinels are stored on the immutable padding object; every backend (OpenSSL, CNG, BCrypt, Android, Apple, plus the managed RsaPaddingProcessor) resolves the sentinels through a single new RsaPaddingProcessor.CalculatePssSaltLength helper, and platforms that cannot honor a custom length (Apple, COSE) throw rather than silently ignore it. This directly follows the implementation checklist bartonjs posted on the approved issue (encode/verify, certificate PssParams, PssParamsAsn rehydration, CMS/COSE, and tests).

Summary: ⚠️ Needs Human Review. I found no blocking defects and verified the public surface matches the approved API exactly, but this is a large, security-sensitive cryptographic change spanning five platform backends plus CMS/COSE/X.509 encoding, and the area owner (bartonjs) has an in-flight review (previously CHANGES_REQUESTED). A crypto-domain maintainer should confirm the salt-length math and per-platform semantics before merge.

Detailed Findings

✅ API Approval — Matches approved shape

The new public surface in ref/System.Security.Cryptography.cs (const int PssSaltLengthIsHashLength = -1, const int PssSaltLengthMax = -2, int PssSaltLength { get; }, static RSASignaturePadding CreatePss(int saltLength)) is byte-for-byte identical to the shape approved by bartonjs (who applied the api-approved label on 2025-06-03) in the issue comment. Namespaces, type, member names, and signatures all match; no extra or missing public API.

✅ Cross-platform completeness — sentinels resolved centrally, unsupported paths throw

Sentinel values (-1/-2) are never leaked to native layers or the managed encoder: each caller resolves them via RsaPaddingProcessor.CalculatePssSaltLength(padding.PssSaltLength, KeySize, hashAlgorithm) before use (RSAOpenSsl, RSACng.SignVerify, RSABCrypt, RSAAndroid, RSAAppleCrypto). Backends that cannot honor a non-hLen salt reject it: Apple's ValidatePaddingParameters (called from both TrySignHash and VerifyHash) throws Cryptography_CustomPssSaltLengthNotSupported, and COSE's GetRSAAlgorithm throws because the spec mandates sLen==hLen. The EncodePss/VerifyPss emLen < 2 + hLen + sLen guard plus the PssSaltLengthTooLarge test protect against over-large explicit salts, and EncodePss moves the salt buffer to the heap when sLen > 128 to avoid an unbounded stackalloc.

✅ Test coverage — thorough and interop-anchored

Tests exercise explicit lengths, PssSaltLengthMax, and hLen equivalence, use externally-generated OpenSSL signatures as known-answer vectors, assert cross-verification between implicit Pss and explicit CreatePss(hLen), verify wrong salt lengths fail, and cover CMS/COSE/CertificateRequest. Coverage is gated by AreCustomSaltLengthsSupportedWithPss (excludes Apple), matching the platform capabilities.

💡 Stale comment in `RsaPaddingProcessor.EncodePss`

The comment // sLen = hLen in this implementation. (RsaPaddingProcessor.cs, in EncodePss near the emLen < 2 + hLen + sLen check) is now inaccurate since sLen comes from the caller-supplied saltLength. It sits on an unchanged line so I did not attach an inline comment; consider removing it to avoid confusion. Non-blocking.

Note

This review was generated by this repository's Holistic Review agentic workflow to complement the built-in Copilot review.

Generated by Holistic Review · 275.2 AIC · ⌖ 10.7 AIC · ⊞ 10K

henning-krause and others added 23 commits May 16, 2025 11:32

Added support for a custom salt length when using PSS signature valid…

e0b1dae

…ation/generation with RSA keys. dotnet#104080

Review

05ed28b

Merge branch 'dotnet:main' into 104080-custom-rsapss-salt-length

21135d5

Review all usages for RSASignaturePadding to check for missing PSS sa…

d705126

…lt customizations

Added error handling for apple devices (custom PSS salt length not su…

3c6288c

…pported there) Updated reference code

Added sign and verify tests for custom salt lengths

4d3bd37

Added test for max salt length verification

d19d017

Added a test for the RSAPssX509SignatureGenerator

20be62b

Added test for CertificateRequest.LoadSigningRequest

c0d0ce0

More tests for the CertificateRequest

81432d5

Added custom salt support for SignedCms

a016382

Add error handling for PSS salt length in CoseSigner

9cde2fa

Cose does not support custom salt lengths with PSS.

Updated RSA

a6dd48a

Merged from main

71325e3

Updated CoseSigner

e2407be

Code fixes

7b65140

Code fixes

623199c

Code fixes

b14906e

Code fixes

9dcb4ea

Code fixes

fee0f09

Code fixes

a386bac

Updated a few test cases

430a846

CRL Builder tests extended

e0eb704

Copilot AI review requested due to automatic review settings September 2, 2025 05:45

github-actions Bot added the area-System.Security label Sep 2, 2025

dotnet-policy-service Bot added the community-contribution Indicates that the PR has been added by a community member label Sep 2, 2025

Copilot AI reviewed Sep 2, 2025

View reviewed changes

henning-krause and others added 3 commits September 2, 2025 07:51

Update src/libraries/System.Security.Cryptography/tests/X509Certifica…

dd64636

…tes/CertificateCreation/CertificateRequestChainTests.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Update src/libraries/System.Security.Cryptography/ref/System.Security…

d97581c

….Cryptography.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Update src/libraries/Common/src/System/Security/Cryptography/RsaPaddi…

e99f10d

…ngProcessor.DigestInfo.cs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Review

ed35977

Copilot AI review requested due to automatic review settings June 9, 2026 08:15

Copilot AI reviewed Jun 9, 2026

View reviewed changes

build-analysis Bot mentioned this pull request Jun 9, 2026

Error while retrieving client Settings for PipelineArtifact. HttpRequestException: nodename nor servname provided, or not known (vsblobprodcus3.vsblob.visualstudio.com:443) #96798

Open

bartonjs requested changes Jun 18, 2026

View reviewed changes

Update src/libraries/Common/tests/System/Security/Cryptography/Algori…

0346b98

…thmImplementations/RSA/SignVerify.cs Co-authored-by: Jeremy Barton <jbarton@microsoft.com>

Copilot AI review requested due to automatic review settings June 19, 2026 05:34

Copilot started reviewing on behalf of henning-krause June 19, 2026 05:34 View session

Copilot AI reviewed Jun 19, 2026

View reviewed changes

henning-krause added 3 commits July 15, 2026 07:18

Merge remote-tracking branch 'origin/main' into 104080-custom-rsapss-…

fca0b13

…salt-length

Fix issues mentioned in the PR review

6404279

Merge branch '104080-custom-rsapss-salt-length' of https://github.com…

1590f92

…/henning-krause/runtime into 104080-custom-rsapss-salt-length

Copilot AI review requested due to automatic review settings July 15, 2026 07:39

Copilot started reviewing on behalf of henning-krause July 15, 2026 07:39 View session

Copilot AI reviewed Jul 15, 2026

View reviewed changes

Fixed tests

fa75ead

Copilot AI review requested due to automatic review settings July 15, 2026 11:29

Copilot started reviewing on behalf of henning-krause July 15, 2026 11:29 View session

Copilot AI reviewed Jul 15, 2026

View reviewed changes

Merge remote-tracking branch 'origin/main' into 104080-custom-rsapss-…

f0fb442

…salt-length

Copilot AI review requested due to automatic review settings July 15, 2026 12:44

Copilot started reviewing on behalf of henning-krause July 15, 2026 12:44 View session

Copilot AI reviewed Jul 15, 2026

View reviewed changes

Review

d0d88a2

Copilot AI review requested due to automatic review settings July 15, 2026 17:51

Copilot started reviewing on behalf of henning-krause July 15, 2026 17:51 View session

Copilot AI reviewed Jul 15, 2026

View reviewed changes

github-actions Bot reviewed Jul 19, 2026

View reviewed changes

-        }
-    }
+        }
+    }

Uh oh!

Conversation

henning-krause commented Sep 2, 2025 • edited by jeffhandley Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull Request Overview

Reviewed Changes

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

henning-krause commented Jul 15, 2026

Uh oh!

Copilot AI left a comment

Choose a reason for hiding this comment

Pull request overview

Uh oh!

github-actions Bot commented Jul 19, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

github-actions Bot left a comment

Choose a reason for hiding this comment

Holistic Review

Detailed Findings

✅ API Approval — Matches approved shape

✅ Cross-platform completeness — sentinels resolved centrally, unsupported paths throw

✅ Test coverage — thorough and interop-anchored

💡 Stale comment in RsaPaddingProcessor.EncodePss

Uh oh!

Reviewers

Assignees

Labels

henning-krause commented Sep 2, 2025 •

edited by jeffhandley

Loading

github-actions Bot commented Jul 19, 2026 •

edited

Loading

💡 Stale comment in `RsaPaddingProcessor.EncodePss`