[release/6.0] disable sending NT Authority in TLS handshake if specific trust was specified (#61713)

github-actions[bot] · wfurt · scalablecory · web-flow · commit fb56c4c3b77a · 2021-12-15T12:29:01.000-06:00
* diable sending NT Authority if specific trust was specified

* feedback from review

* add missing file

* Apply suggestions from code review

Co-authored-by: Cory Nelson &lt;phrosty@gmail.com&gt;

* one more style update

Co-authored-by: wfurt &lt;tweinfurt@yahoo.com&gt;
Co-authored-by: Cory Nelson &lt;phrosty@gmail.com&gt;
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SecureChannel.cs
@@ -695,11 +695,13 @@ private bool AcquireServerCredentials(ref byte[]? thumbPrint)
                 _sslAuthenticationOptions.CertificateContext = SslStreamCertificateContext.Create(selectedCert);
             }
 
+            Debug.Assert(_sslAuthenticationOptions.CertificateContext != null);
             //
             // Note selectedCert is a safe ref possibly cloned from the user passed Cert object
             //
             byte[] guessedThumbPrint = selectedCert.GetCertHash();
-            SafeFreeCredentials? cachedCredentialHandle = SslSessionsCache.TryCachedCredential(guessedThumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy);
+            bool sendTrustedList = _sslAuthenticationOptions.CertificateContext!.Trust?._sendTrustInHandshake ?? false;
+            SafeFreeCredentials? cachedCredentialHandle = SslSessionsCache.TryCachedCredential(guessedThumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy, sendTrustedList);
 
             if (cachedCredentialHandle != null)
             {
@@ -763,6 +765,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
             byte[]? result = Array.Empty<byte>();
             SecurityStatusPal status = default;
             bool cachedCreds = false;
+            bool sendTrustList = false;
             byte[]? thumbPrint = null;
 
             //
@@ -779,6 +782,11 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
                         cachedCreds = _sslAuthenticationOptions.IsServer
                                         ? AcquireServerCredentials(ref thumbPrint)
                                         : AcquireClientCredentials(ref thumbPrint);
+
+                        if (cachedCreds && _sslAuthenticationOptions.IsServer)
+                        {
+                            sendTrustList = _sslAuthenticationOptions.CertificateContext?.Trust?._sendTrustInHandshake ?? false;
+                        }
                     }
 
                     if (_sslAuthenticationOptions.IsServer)
@@ -820,7 +828,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte
                     //
                     if (!cachedCreds && _securityContext != null && !_securityContext.IsInvalid && _credentialsHandle != null && !_credentialsHandle.IsInvalid)
                     {
-                        SslSessionsCache.CacheCredential(_credentialsHandle, thumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy);
+                        SslSessionsCache.CacheCredential(_credentialsHandle, thumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy, sendTrustList);
                     }
                 }
             }
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslSessionsCache.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslSessionsCache.cs
@@ -25,18 +25,20 @@ internal static class SslSessionsCache
             private readonly int _allowedProtocols;
             private readonly EncryptionPolicy _encryptionPolicy;
             private readonly bool _isServerMode;
+            private readonly bool _sendTrustList;
 
             //
             // SECURITY: X509Certificate.GetCertHash() is virtual hence before going here,
             //           the caller of this ctor has to ensure that a user cert object was inspected and
             //           optionally cloned.
             //
-            internal SslCredKey(byte[]? thumbPrint, int allowedProtocols, bool isServerMode, EncryptionPolicy encryptionPolicy)
+            internal SslCredKey(byte[]? thumbPrint, int allowedProtocols, bool isServerMode, EncryptionPolicy encryptionPolicy, bool sendTrustList)
             {
                 _thumbPrint = thumbPrint ?? Array.Empty<byte>();
                 _allowedProtocols = allowedProtocols;
                 _encryptionPolicy = encryptionPolicy;
                 _isServerMode = isServerMode;
+                _sendTrustList = sendTrustList;
             }
 
             public override int GetHashCode()
@@ -65,6 +67,7 @@ public override int GetHashCode()
                 hashCode ^= _allowedProtocols;
                 hashCode ^= (int)_encryptionPolicy;
                 hashCode ^= _isServerMode ? 0x10000 : 0x20000;
+                hashCode ^= _sendTrustList ? 0x40000 : 0x80000;
 
                 return hashCode;
             }
@@ -96,6 +99,11 @@ public bool Equals(SslCredKey other)
                     return false;
                 }
 
+                if (_sendTrustList != other._sendTrustList)
+                {
+                    return false;
+                }
+
                 for (int i = 0; i < thumbPrint.Length; ++i)
                 {
                     if (thumbPrint[i] != otherThumbPrint[i])
@@ -114,15 +122,15 @@ public bool Equals(SslCredKey other)
         // ATTN: The returned handle can be invalid, the callers of InitializeSecurityContext and AcceptSecurityContext
         // must be prepared to execute a back-out code if the call fails.
         //
-        internal static SafeFreeCredentials? TryCachedCredential(byte[]? thumbPrint, SslProtocols sslProtocols, bool isServer, EncryptionPolicy encryptionPolicy)
+        internal static SafeFreeCredentials? TryCachedCredential(byte[]? thumbPrint, SslProtocols sslProtocols, bool isServer, EncryptionPolicy encryptionPolicy, bool sendTrustList = false)
         {
             if (s_cachedCreds.IsEmpty)
             {
                 if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(null, $"Not found, Current Cache Count = {s_cachedCreds.Count}");
                 return null;
             }
 
-            var key = new SslCredKey(thumbPrint, (int)sslProtocols, isServer, encryptionPolicy);
+            var key = new SslCredKey(thumbPrint, (int)sslProtocols, isServer, encryptionPolicy, sendTrustList);
 
             //SafeCredentialReference? cached;
             SafeFreeCredentials? credentials = GetCachedCredential(key);
@@ -147,7 +155,7 @@ public bool Equals(SslCredKey other)
         //
         // ATTN: The thumbPrint must be from inspected and possibly cloned user Cert object or we get a security hole in SslCredKey ctor.
         //
-        internal static void CacheCredential(SafeFreeCredentials creds, byte[]? thumbPrint, SslProtocols sslProtocols, bool isServer, EncryptionPolicy encryptionPolicy)
+        internal static void CacheCredential(SafeFreeCredentials creds, byte[]? thumbPrint, SslProtocols sslProtocols, bool isServer, EncryptionPolicy encryptionPolicy, bool sendTrustList = false)
         {
             Debug.Assert(creds != null, "creds == null");
 
@@ -157,7 +165,7 @@ internal static void CacheCredential(SafeFreeCredentials creds, byte[]? thumbPri
                 return;
             }
 
-            SslCredKey key = new SslCredKey(thumbPrint, (int)sslProtocols, isServer, encryptionPolicy);
+            SslCredKey key = new SslCredKey(thumbPrint, (int)sslProtocols, isServer, encryptionPolicy, sendTrustList);
 
             SafeFreeCredentials? credentials = GetCachedCredential(key);
 
diff --git a/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs b/src/libraries/System.Net.Security/src/System/Net/Security/SslStreamPal.Windows.cs
@@ -124,8 +124,8 @@ public static SafeFreeCredentials AcquireCredentialsHandle(SslStreamCertificateC
         {
             // New crypto API supports TLS1.3 but it does not allow to force NULL encryption.
             SafeFreeCredentials cred = !UseNewCryptoApi || policy == EncryptionPolicy.NoEncryption ?
-                        AcquireCredentialsHandleSchannelCred(certificateContext?.Certificate, protocols, policy, isServer) :
-                        AcquireCredentialsHandleSchCredentials(certificateContext?.Certificate, protocols, policy, isServer);
+                        AcquireCredentialsHandleSchannelCred(certificateContext, protocols, policy, isServer) :
+                        AcquireCredentialsHandleSchCredentials(certificateContext, protocols, policy, isServer);
             if (certificateContext != null && certificateContext.Trust != null && certificateContext.Trust._sendTrustInHandshake)
             {
                 AttachCertificateStore(cred, certificateContext.Trust._store!);
@@ -157,8 +157,9 @@ private static unsafe void AttachCertificateStore(SafeFreeCredentials cred, X509
 
         // This is legacy crypto API used on .NET Framework and older Windows versions.
         // It only supports TLS up to 1.2
-        public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X509Certificate2? certificate, SslProtocols protocols, EncryptionPolicy policy, bool isServer)
+        public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(SslStreamCertificateContext? certificateContext, SslProtocols protocols, EncryptionPolicy policy, bool isServer)
         {
+            X509Certificate2? certificate = certificateContext?.Certificate;
             int protocolFlags = GetProtocolFlagsFromSslProtocols(protocols, isServer);
             Interop.SspiCli.SCHANNEL_CRED.Flags flags;
             Interop.SspiCli.CredentialUse direction;
@@ -183,6 +184,10 @@ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X5
             {
                 direction = Interop.SspiCli.CredentialUse.SECPKG_CRED_INBOUND;
                 flags = Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_SEND_AUX_RECORD;
+                if (certificateContext?.Trust?._sendTrustInHandshake == true)
+                {
+                    flags |= Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_CRED_NO_SYSTEM_MAPPER;
+                }
             }
 
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info($"flags=({flags}), ProtocolFlags=({protocolFlags}), EncryptionPolicy={policy}");
@@ -203,15 +208,20 @@ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X5
         }
 
         // This function uses new crypto API to support TLS 1.3 and beyond.
-        public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchCredentials(X509Certificate2? certificate, SslProtocols protocols, EncryptionPolicy policy, bool isServer)
+        public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchCredentials(SslStreamCertificateContext? certificateContext, SslProtocols protocols, EncryptionPolicy policy, bool isServer)
         {
+            X509Certificate2? certificate = certificateContext?.Certificate;
             int protocolFlags = GetProtocolFlagsFromSslProtocols(protocols, isServer);
             Interop.SspiCli.SCH_CREDENTIALS.Flags flags;
             Interop.SspiCli.CredentialUse direction;
             if (isServer)
             {
                 direction = Interop.SspiCli.CredentialUse.SECPKG_CRED_INBOUND;
                 flags = Interop.SspiCli.SCH_CREDENTIALS.Flags.SCH_SEND_AUX_RECORD;
+                if (certificateContext?.Trust?._sendTrustInHandshake == true)
+                {
+                    flags |= Interop.SspiCli.SCH_CREDENTIALS.Flags.SCH_CRED_NO_SYSTEM_MAPPER;
+                }
             }
             else
             {

Original file line number	Diff line number	Diff line change
`@@ -695,11 +695,13 @@ private bool AcquireServerCredentials(ref byte[]? thumbPrint)`
`695`	`695`	`_sslAuthenticationOptions.CertificateContext = SslStreamCertificateContext.Create(selectedCert);`
`696`	`696`	`}`
`697`	`697`
	`698`	`+ Debug.Assert(_sslAuthenticationOptions.CertificateContext != null);`
`698`	`699`	`//`
`699`	`700`	`// Note selectedCert is a safe ref possibly cloned from the user passed Cert object`
`700`	`701`	`//`
`701`	`702`	`byte[] guessedThumbPrint = selectedCert.GetCertHash();`
`702`		`- SafeFreeCredentials? cachedCredentialHandle = SslSessionsCache.TryCachedCredential(guessedThumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy);`
	`703`	`+ bool sendTrustedList = _sslAuthenticationOptions.CertificateContext!.Trust?._sendTrustInHandshake ?? false;`
	`704`	`+ SafeFreeCredentials? cachedCredentialHandle = SslSessionsCache.TryCachedCredential(guessedThumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy, sendTrustedList);`
`703`	`705`
`704`	`706`	`if (cachedCredentialHandle != null)`
`705`	`707`	`{`
`@@ -763,6 +765,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte`
`763`	`765`	`byte[]? result = Array.Empty<byte>();`
`764`	`766`	`SecurityStatusPal status = default;`
`765`	`767`	`bool cachedCreds = false;`
	`768`	`+ bool sendTrustList = false;`
`766`	`769`	`byte[]? thumbPrint = null;`
`767`	`770`
`768`	`771`	`//`
`@@ -779,6 +782,11 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte`
`779`	`782`	`cachedCreds = _sslAuthenticationOptions.IsServer`
`780`	`783`	`? AcquireServerCredentials(ref thumbPrint)`
`781`	`784`	`: AcquireClientCredentials(ref thumbPrint);`
	`785`	`+`
	`786`	`+ if (cachedCreds && _sslAuthenticationOptions.IsServer)`
	`787`	`+ {`
	`788`	`+ sendTrustList = _sslAuthenticationOptions.CertificateContext?.Trust?._sendTrustInHandshake ?? false;`
	`789`	`+ }`
`782`	`790`	`}`
`783`	`791`
`784`	`792`	`if (_sslAuthenticationOptions.IsServer)`
`@@ -820,7 +828,7 @@ private SecurityStatusPal GenerateToken(ReadOnlySpan<byte> inputBuffer, ref byte`
`820`	`828`	`//`
`821`	`829`	`if (!cachedCreds && _securityContext != null && !_securityContext.IsInvalid && _credentialsHandle != null && !_credentialsHandle.IsInvalid)`
`822`	`830`	`{`
`823`		`- SslSessionsCache.CacheCredential(_credentialsHandle, thumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy);`
	`831`	`+ SslSessionsCache.CacheCredential(_credentialsHandle, thumbPrint, _sslAuthenticationOptions.EnabledSslProtocols, _sslAuthenticationOptions.IsServer, _sslAuthenticationOptions.EncryptionPolicy, sendTrustList);`
`824`	`832`	`}`
`825`	`833`	`}`
`826`	`834`	`}`
Original file line number	Diff line number	Diff line change
`@@ -124,8 +124,8 @@ public static SafeFreeCredentials AcquireCredentialsHandle(SslStreamCertificateC`
`124`	`124`	`{`
`125`	`125`	`// New crypto API supports TLS1.3 but it does not allow to force NULL encryption.`
`126`	`126`	`SafeFreeCredentials cred = !UseNewCryptoApi \|\| policy == EncryptionPolicy.NoEncryption ?`
`127`		`- AcquireCredentialsHandleSchannelCred(certificateContext?.Certificate, protocols, policy, isServer) :`
`128`		`- AcquireCredentialsHandleSchCredentials(certificateContext?.Certificate, protocols, policy, isServer);`
	`127`	`+ AcquireCredentialsHandleSchannelCred(certificateContext, protocols, policy, isServer) :`
	`128`	`+ AcquireCredentialsHandleSchCredentials(certificateContext, protocols, policy, isServer);`
`129`	`129`	`if (certificateContext != null && certificateContext.Trust != null && certificateContext.Trust._sendTrustInHandshake)`
`130`	`130`	`{`
`131`	`131`	`AttachCertificateStore(cred, certificateContext.Trust._store!);`
`@@ -157,8 +157,9 @@ private static unsafe void AttachCertificateStore(SafeFreeCredentials cred, X509`
`157`	`157`
`158`	`158`	`// This is legacy crypto API used on .NET Framework and older Windows versions.`
`159`	`159`	`// It only supports TLS up to 1.2`
`160`		`- public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X509Certificate2? certificate, SslProtocols protocols, EncryptionPolicy policy, bool isServer)`
	`160`	`+ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(SslStreamCertificateContext? certificateContext, SslProtocols protocols, EncryptionPolicy policy, bool isServer)`
`161`	`161`	`{`
	`162`	`+ X509Certificate2? certificate = certificateContext?.Certificate;`
`162`	`163`	`int protocolFlags = GetProtocolFlagsFromSslProtocols(protocols, isServer);`
`163`	`164`	`Interop.SspiCli.SCHANNEL_CRED.Flags flags;`
`164`	`165`	`Interop.SspiCli.CredentialUse direction;`
`@@ -183,6 +184,10 @@ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X5`
`183`	`184`	`{`
`184`	`185`	`direction = Interop.SspiCli.CredentialUse.SECPKG_CRED_INBOUND;`
`185`	`186`	`flags = Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_SEND_AUX_RECORD;`
	`187`	`+ if (certificateContext?.Trust?._sendTrustInHandshake == true)`
	`188`	`+ {`
	`189`	`+ flags \|= Interop.SspiCli.SCHANNEL_CRED.Flags.SCH_CRED_NO_SYSTEM_MAPPER;`
	`190`	`+ }`
`186`	`191`	`}`
`187`	`192`
`188`	`193`	`if (NetEventSource.Log.IsEnabled()) NetEventSource.Info($"flags=({flags}), ProtocolFlags=({protocolFlags}), EncryptionPolicy={policy}");`
`@@ -203,15 +208,20 @@ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchannelCred(X5`
`203`	`208`	`}`
`204`	`209`
`205`	`210`	`// This function uses new crypto API to support TLS 1.3 and beyond.`
`206`		`- public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchCredentials(X509Certificate2? certificate, SslProtocols protocols, EncryptionPolicy policy, bool isServer)`
	`211`	`+ public static unsafe SafeFreeCredentials AcquireCredentialsHandleSchCredentials(SslStreamCertificateContext? certificateContext, SslProtocols protocols, EncryptionPolicy policy, bool isServer)`
`207`	`212`	`{`
	`213`	`+ X509Certificate2? certificate = certificateContext?.Certificate;`
`208`	`214`	`int protocolFlags = GetProtocolFlagsFromSslProtocols(protocols, isServer);`
`209`	`215`	`Interop.SspiCli.SCH_CREDENTIALS.Flags flags;`
`210`	`216`	`Interop.SspiCli.CredentialUse direction;`
`211`	`217`	`if (isServer)`
`212`	`218`	`{`
`213`	`219`	`direction = Interop.SspiCli.CredentialUse.SECPKG_CRED_INBOUND;`
`214`	`220`	`flags = Interop.SspiCli.SCH_CREDENTIALS.Flags.SCH_SEND_AUX_RECORD;`
	`221`	`+ if (certificateContext?.Trust?._sendTrustInHandshake == true)`
	`222`	`+ {`
	`223`	`+ flags \|= Interop.SspiCli.SCH_CREDENTIALS.Flags.SCH_CRED_NO_SYSTEM_MAPPER;`
	`224`	`+ }`
`215`	`225`	`}`
`216`	`226`	`else`
`217`	`227`	`{`