Support raw ECDH key agreements

vcsjones · web-flow · commit be823a152f76 · 2023-03-03T09:54:13.000-05:00
diff --git a/src/libraries/Common/src/Interop/Windows/BCrypt/Cng.cs b/src/libraries/Common/src/Interop/Windows/BCrypt/Cng.cs
@@ -45,6 +45,7 @@ internal static class KeyDerivationFunction
             public const string Hash = "HASH";                  // BCRYPT_KDF_HASH
             public const string Hmac = "HMAC";                  // BCRYPT_KDF_HMAC
             public const string Tls = "TLS_PRF";                // BCRYPT_KDF_TLS_PRF
+            public const string Raw = "TRUNCATE";               // BCRYPT_KDF_RAW_SECRET
         }
     }
 
diff --git a/src/libraries/Common/src/Interop/Windows/NCrypt/Interop.NCryptDeriveKeyMaterial.cs b/src/libraries/Common/src/Interop/Windows/NCrypt/Interop.NCryptDeriveKeyMaterial.cs
@@ -241,5 +241,25 @@ internal static unsafe byte[] DeriveKeyMaterialTls(
                     flags);
             }
         }
+
+        internal static unsafe byte[] DeriveKeyMaterialTruncate(
+            SafeNCryptSecretHandle secretAgreement,
+            SecretAgreementFlags flags)
+        {
+            if (!OperatingSystem.IsWindowsVersionAtLeast(10))
+            {
+                throw new PlatformNotSupportedException();
+            }
+
+            byte[] result = DeriveKeyMaterial(
+                secretAgreement,
+                BCryptNative.KeyDerivationFunction.Raw,
+                ReadOnlySpan<NCryptBuffer>.Empty,
+                flags);
+
+            // Win32 returns the result as little endian. So we need to flip it to big endian.
+            Array.Reverse(result);
+            return result;
+        }
     }
 }
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanAndroid.Derive.cs
@@ -72,6 +72,16 @@ public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey
                     DeriveSecretAgreement);
             }
 
+            public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)
+            {
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ThrowIfDisposed();
+
+                byte[]? secretAgreement = DeriveSecretAgreement(otherPartyPublicKey, hasher: null);
+                Debug.Assert(secretAgreement is not null);
+                return secretAgreement;
+            }
+
             /// <summary>
             /// Get the secret agreement generated between two parties
             /// </summary>
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanCng.cs
@@ -130,5 +130,18 @@ public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey
                     Interop.NCrypt.SecretAgreementFlags.None);
             }
         }
+
+        /// <inheritdoc />
+        public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)
+        {
+            ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+
+            using (SafeNCryptSecretHandle secretAgreement = DeriveSecretAgreementHandle(otherPartyPublicKey))
+            {
+                return Interop.NCrypt.DeriveKeyMaterialTruncate(
+                    secretAgreement,
+                    Interop.NCrypt.SecretAgreementFlags.None);
+            }
+        }
     }
 }
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanOpenSsl.Derive.cs
@@ -69,6 +69,17 @@ public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey
                 DeriveSecretAgreement);
         }
 
+        /// <inheritdoc />
+        public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)
+        {
+            ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+            ThrowIfDisposed();
+
+            byte[]? secretAgreement = DeriveSecretAgreement(otherPartyPublicKey, hasher: null);
+            Debug.Assert(secretAgreement is not null);
+            return secretAgreement;
+        }
+
         /// <summary>
         /// Get the secret agreement generated between two parties
         /// </summary>
diff --git a/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs b/src/libraries/Common/src/System/Security/Cryptography/ECDiffieHellmanSecurityTransforms.cs
@@ -165,6 +165,16 @@ public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey
                     DeriveSecretAgreement);
             }
 
+            public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)
+            {
+                ArgumentNullException.ThrowIfNull(otherPartyPublicKey);
+                ThrowIfDisposed();
+
+                byte[]? secretAgreement = DeriveSecretAgreement(otherPartyPublicKey, hasher: null);
+                Debug.Assert(secretAgreement is not null);
+                return secretAgreement;
+            }
+
             private byte[]? DeriveSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey, IncrementalHash? hasher)
             {
                 if (!(otherPartyPublicKey is ECDiffieHellmanSecurityTransformsPublicKey secTransPubKey))
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanFactory.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanFactory.cs
@@ -13,6 +13,7 @@ public interface IECDiffieHellmanProvider
         bool IsCurveValid(Oid oid);
         bool ExplicitCurvesSupported { get; }
         bool CanDeriveNewPublicKey { get; }
+        bool SupportsRawDerivation { get; }
     }
 
     public static partial class ECDiffieHellmanFactory
@@ -42,5 +43,7 @@ public static bool IsCurveValid(Oid oid)
         public static bool ExplicitCurvesSupported => s_provider.ExplicitCurvesSupported;
 
         public static bool CanDeriveNewPublicKey => s_provider.CanDeriveNewPublicKey;
+
+        public static bool SupportsRawDerivation => s_provider.SupportsRawDerivation;
     }
 }
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanTests.NistValidation.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanTests.NistValidation.cs
@@ -223,9 +223,19 @@ private static void Verify(
             HashAlgorithmName zHashAlgorithm,
             byte[] iutZ)
         {
-            byte[] result = iut.DeriveKeyFromHash(cavsPublic, zHashAlgorithm);
+            byte[] deriveHash = iut.DeriveKeyFromHash(cavsPublic, zHashAlgorithm);
             byte[] hashedZ = zHasher.ComputeHash(iutZ);
-            Assert.Equal(hashedZ.ByteArrayToHex(), result.ByteArrayToHex());
+            Assert.Equal(hashedZ.ByteArrayToHex(), deriveHash.ByteArrayToHex());
+
+            if (ECDiffieHellmanFactory.SupportsRawDerivation)
+            {
+                byte[] rawDerived = iut.DeriveRawSecretAgreement(cavsPublic);
+                Assert.Equal(iutZ.ByteArrayToHex(), rawDerived.ByteArrayToHex());
+            }
+            else
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => iut.DeriveRawSecretAgreement(cavsPublic));
+            }
         }
     }
 #endif
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanTests.Raw.cs b/src/libraries/Common/tests/System/Security/Cryptography/AlgorithmImplementations/ECDiffieHellman/ECDiffieHellmanTests.Raw.cs
@@ -0,0 +1,94 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Security.Cryptography;
+using Xunit;
+
+namespace System.Security.Cryptography.EcDiffieHellman.Tests
+{
+    public partial class ECDiffieHellmanTests
+    {
+        public static bool DoesNotSupportRawDerivation => !ECDiffieHellmanFactory.SupportsRawDerivation;
+
+        [ConditionalFact(typeof(ECDiffieHellmanFactory), nameof(ECDiffieHellmanFactory.SupportsRawDerivation))]
+        public static void RawDerivation_OtherKeyRequired()
+        {
+            using (ECDiffieHellman ecdh = ECDiffieHellmanFactory.Create())
+            {
+                AssertExtensions.Throws<ArgumentNullException>(
+                    "otherPartyPublicKey",
+                    () => ecdh.DeriveRawSecretAgreement(null));
+            }
+        }
+
+        [ConditionalTheory(typeof(ECDiffieHellmanFactory), nameof(ECDiffieHellmanFactory.SupportsRawDerivation))]
+        [MemberData(nameof(MismatchedKeysizes))]
+        public static void RawDerivation_SameSizeOtherKeyRequired(int aliceSize, int bobSize)
+        {
+            using (ECDiffieHellman alice = ECDiffieHellmanFactory.Create(aliceSize))
+            using (ECDiffieHellman bob = ECDiffieHellmanFactory.Create(bobSize))
+            using (ECDiffieHellmanPublicKey bobPublic = bob.PublicKey)
+            {
+                AssertExtensions.Throws<ArgumentException>(
+                    "otherPartyPublicKey",
+                    () => alice.DeriveRawSecretAgreement(bobPublic));
+            }
+        }
+
+        [ConditionalTheory(typeof(ECDiffieHellmanFactory), nameof(ECDiffieHellmanFactory.SupportsRawDerivation))]
+        [MemberData(nameof(EveryKeysize))]
+        public static void RawDerivation_DeriveSharedSecret_Agree(int keySize)
+        {
+            using (ECDiffieHellman alice = ECDiffieHellmanFactory.Create(keySize))
+            using (ECDiffieHellman bob = ECDiffieHellmanFactory.Create(keySize))
+            using (ECDiffieHellmanPublicKey alicePublic = alice.PublicKey)
+            using (ECDiffieHellmanPublicKey bobPublic = bob.PublicKey)
+            {
+                byte[] aliceDerived = alice.DeriveRawSecretAgreement(bobPublic);
+                byte[] bobDerived = bob.DeriveRawSecretAgreement(alicePublic);
+                Assert.Equal(aliceDerived, bobDerived);
+            }
+        }
+
+        [ConditionalFact(typeof(ECDiffieHellmanFactory), nameof(ECDiffieHellmanFactory.SupportsRawDerivation))]
+        public static void RawDerivation_DeriveSharedSecret_Disagree()
+        {
+            using (ECDiffieHellman alice = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellman bob = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellman eve = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellmanPublicKey bobPublic = bob.PublicKey)
+            using (ECDiffieHellmanPublicKey evePublic = eve.PublicKey)
+            {
+                byte[] aliceDerived = alice.DeriveRawSecretAgreement(bobPublic);
+                byte[] eveDerived = alice.DeriveRawSecretAgreement(evePublic);
+
+                Assert.NotEqual(aliceDerived, eveDerived);
+            }
+        }
+
+        [ConditionalFact(typeof(ECDiffieHellmanFactory), nameof(ECDiffieHellmanFactory.SupportsRawDerivation))]
+        public static void RawDerivation_DeriveIsStable()
+        {
+            using (ECDiffieHellman alice = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellman bob = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellmanPublicKey bobPublic = bob.PublicKey)
+            {
+                byte[] aliceDerived1 = alice.DeriveRawSecretAgreement(bobPublic);
+                byte[] aliceDerived2 = alice.DeriveRawSecretAgreement(bobPublic);
+                Assert.Equal(aliceDerived1, aliceDerived2);
+            }
+        }
+
+        [ConditionalFact(nameof(DoesNotSupportRawDerivation))]
+        public static void RawDerivation_NotSupported()
+        {
+            using (ECDiffieHellman alice = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellman bob = ECDiffieHellmanFactory.Create(ECCurve.NamedCurves.nistP256))
+            using (ECDiffieHellmanPublicKey bobPublic = bob.PublicKey)
+            {
+                Assert.Throws<PlatformNotSupportedException>(() => alice.DeriveRawSecretAgreement(bobPublic));
+            }
+        }
+    }
+}
diff --git a/src/libraries/System.Security.Cryptography.Cng/tests/ECDiffieHellmanCngProvider.cs b/src/libraries/System.Security.Cryptography.Cng/tests/ECDiffieHellmanCngProvider.cs
@@ -35,6 +35,7 @@ public bool ExplicitCurvesSupported
         }
 
         public bool CanDeriveNewPublicKey => true;
+        public bool SupportsRawDerivation => PlatformDetection.IsWindows10OrLater;
 
         private static bool NativeOidFriendlyNameExists(string oidFriendlyName)
         {
diff --git a/src/libraries/System.Security.Cryptography.Cng/tests/System.Security.Cryptography.Cng.Tests.csproj b/src/libraries/System.Security.Cryptography.Cng/tests/System.Security.Cryptography.Cng.Tests.csproj
@@ -176,6 +176,8 @@
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.ImportExport.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs" />
+    <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs"
+             Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Xml.cs"
diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDiffieHellmanOpenSslProvider.cs b/src/libraries/System.Security.Cryptography.OpenSsl/tests/EcDiffieHellmanOpenSslProvider.cs
@@ -27,6 +27,7 @@ public ECDiffieHellman Create(ECCurve curve)
         public bool ExplicitCurvesSupported => _ecdsaProvider.ExplicitCurvesSupported;
 
         public bool CanDeriveNewPublicKey => true;
+        public bool SupportsRawDerivation => true;
     }
 
     public partial class ECDiffieHellmanFactory
diff --git a/src/libraries/System.Security.Cryptography.OpenSsl/tests/System.Security.Cryptography.OpenSsl.Tests.csproj b/src/libraries/System.Security.Cryptography.OpenSsl/tests/System.Security.Cryptography.OpenSsl.Tests.csproj
@@ -37,6 +37,8 @@
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.ImportExport.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs" />
+    <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs"
+             Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Xml.cs"
diff --git a/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs b/src/libraries/System.Security.Cryptography/ref/System.Security.Cryptography.cs
@@ -969,6 +969,7 @@ protected ECDiffieHellman() { }
         public virtual byte[] DeriveKeyFromHmac(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, byte[]? hmacKey, byte[]? secretPrepend, byte[]? secretAppend) { throw null; }
         public virtual byte[] DeriveKeyMaterial(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey) { throw null; }
         public virtual byte[] DeriveKeyTls(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed) { throw null; }
+        public virtual byte[] DeriveRawSecretAgreement(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey) { throw null; }
         public override void FromXmlString(string xmlString) { }
         public override string ToXmlString(bool includePrivateParameters) { throw null; }
     }
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDiffieHellman.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDiffieHellman.cs
@@ -133,6 +133,35 @@ public virtual byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey,
             throw DerivedClassMustOverride();
         }
 
+        /// <summary>
+        /// Derive raw key material.
+        /// </summary>
+        /// <param name="otherPartyPublicKey">The public key of the party with which to derive a mutual secret.</param>
+        /// <returns>The raw key agreement.</returns>
+        /// <remarks>
+        /// Care must be taking when using the raw derived secret agreement value. The raw value is expected to be used
+        /// as input in to a Key Derivation Function, and not used directly as key material.
+        /// </remarks>
+        /// <exception cref="ArgumentNullException">
+        ///   <paramref name="otherPartyPublicKey"/> is <see langword="null" />.
+        /// </exception>
+        /// <exception cref="ArgumentException">
+        ///   <paramref name="otherPartyPublicKey"/> is over a different curve than this key.
+        /// </exception>
+        /// <exception cref="NotImplementedException">
+        ///   A derived implementation has not provided an implementation of the method.
+        /// </exception>
+        /// <exception cref="PlatformNotSupportedException">
+        ///  The current platform does not support raw key agreement.
+        /// </exception>
+        /// <exception cref="ObjectDisposedException">
+        ///  The object has already been disposed.
+        /// </exception>
+        public virtual byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)
+        {
+            throw DerivedClassMustOverride();
+        }
+
         private static NotImplementedException DerivedClassMustOverride()
         {
             return new NotImplementedException(SR.NotSupported_SubclassOverride);
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDiffieHellmanWrapper.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/ECDiffieHellmanWrapper.cs
@@ -43,6 +43,9 @@ public override byte[] DeriveKeyFromHmac(
         public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed) =>
             _wrapped.DeriveKeyTls(Unwrap(otherPartyPublicKey), prfLabel, prfSeed);
 
+        public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey) =>
+            _wrapped.DeriveRawSecretAgreement(Unwrap(otherPartyPublicKey));
+
         public override void FromXmlString(string xmlString) => _wrapped.FromXmlString(xmlString);
 
         public override string ToXmlString(bool includePrivateParameters) =>
diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Android.cs b/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Android.cs
@@ -21,6 +21,8 @@ public bool IsCurveValid(Oid oid)
 
         public bool CanDeriveNewPublicKey => false;
 
+        public bool SupportsRawDerivation => true;
+
         private static bool IsValueOrFriendlyNameValid(string friendlyNameOrValue)
         {
             if (string.IsNullOrEmpty(friendlyNameOrValue))
diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs b/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Unix.cs
@@ -35,6 +35,7 @@ public bool ExplicitCurvesSupported
         }
 
         public bool CanDeriveNewPublicKey { get; } = !PlatformDetection.IsiOS && !PlatformDetection.IstvOS && !PlatformDetection.IsMacCatalyst;
+        public bool SupportsRawDerivation => true;
 
         private static bool IsValueOrFriendlyNameValid(string friendlyNameOrValue)
         {
diff --git a/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Windows.cs b/src/libraries/System.Security.Cryptography/tests/DefaultECDiffieHellmanProvider.Windows.cs
@@ -23,6 +23,7 @@ public bool ExplicitCurvesSupported
         }
 
         public bool CanDeriveNewPublicKey => true;
+        public bool SupportsRawDerivation => PlatformDetection.IsWindows10OrLater;
 
         private static bool NativeOidFriendlyNameExists(string oidFriendlyName)
         {
diff --git a/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj b/src/libraries/System.Security.Cryptography/tests/System.Security.Cryptography.Tests.csproj
@@ -127,6 +127,8 @@
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.ImportExport.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.NistValidation.cs" />
+    <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs"
+             Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Raw.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs"
              Link="CommonTest\System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Tls.cs" />
     <Compile Include="$(CommonTestPath)System\Security\Cryptography\AlgorithmImplementations\ECDiffieHellman\ECDiffieHellmanTests.Xml.cs"

Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ internal static class KeyDerivationFunction`
`45`	`45`	`public const string Hash = "HASH"; // BCRYPT_KDF_HASH`
`46`	`46`	`public const string Hmac = "HMAC"; // BCRYPT_KDF_HMAC`
`47`	`47`	`public const string Tls = "TLS_PRF"; // BCRYPT_KDF_TLS_PRF`
	`48`	`+ public const string Raw = "TRUNCATE"; // BCRYPT_KDF_RAW_SECRET`
`48`	`49`	`}`
`49`	`50`	`}`
`50`	`51`
Original file line number	Diff line number	Diff line change
`@@ -130,5 +130,18 @@ public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey`
`130`	`130`	`Interop.NCrypt.SecretAgreementFlags.None);`
`131`	`131`	`}`
`132`	`132`	`}`
	`133`	`+`
	`134`	`+ /// <inheritdoc />`
	`135`	`+ public override byte[] DeriveRawSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey)`
	`136`	`+ {`
	`137`	`+ ArgumentNullException.ThrowIfNull(otherPartyPublicKey);`
	`138`	`+`
	`139`	`+ using (SafeNCryptSecretHandle secretAgreement = DeriveSecretAgreementHandle(otherPartyPublicKey))`
	`140`	`+ {`
	`141`	`+ return Interop.NCrypt.DeriveKeyMaterialTruncate(`
	`142`	`+ secretAgreement,`
	`143`	`+ Interop.NCrypt.SecretAgreementFlags.None);`
	`144`	`+ }`
	`145`	`+ }`
`133`	`146`	`}`
`134`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ public interface IECDiffieHellmanProvider`
`13`	`13`	`bool IsCurveValid(Oid oid);`
`14`	`14`	`bool ExplicitCurvesSupported { get; }`
`15`	`15`	`bool CanDeriveNewPublicKey { get; }`
	`16`	`+ bool SupportsRawDerivation { get; }`
`16`	`17`	`}`
`17`	`18`
`18`	`19`	`public static partial class ECDiffieHellmanFactory`
`@@ -42,5 +43,7 @@ public static bool IsCurveValid(Oid oid)`
`42`	`43`	`public static bool ExplicitCurvesSupported => s_provider.ExplicitCurvesSupported;`
`43`	`44`
`44`	`45`	`public static bool CanDeriveNewPublicKey => s_provider.CanDeriveNewPublicKey;`
	`46`	`+`
	`47`	`+ public static bool SupportsRawDerivation => s_provider.SupportsRawDerivation;`
`45`	`48`	`}`
`46`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ public bool ExplicitCurvesSupported`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public bool CanDeriveNewPublicKey => true;`
	`38`	`+ public bool SupportsRawDerivation => PlatformDetection.IsWindows10OrLater;`
`38`	`39`
`39`	`40`	`private static bool NativeOidFriendlyNameExists(string oidFriendlyName)`
`40`	`41`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ public ECDiffieHellman Create(ECCurve curve)`
`27`	`27`	`public bool ExplicitCurvesSupported => _ecdsaProvider.ExplicitCurvesSupported;`
`28`	`28`
`29`	`29`	`public bool CanDeriveNewPublicKey => true;`
	`30`	`+ public bool SupportsRawDerivation => true;`
`30`	`31`	`}`
`31`	`32`
`32`	`33`	`public partial class ECDiffieHellmanFactory`
Original file line number	Diff line number	Diff line change
`@@ -969,6 +969,7 @@ protected ECDiffieHellman() { }`
`969`	`969`	`public virtual byte[] DeriveKeyFromHmac(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey, System.Security.Cryptography.HashAlgorithmName hashAlgorithm, byte[]? hmacKey, byte[]? secretPrepend, byte[]? secretAppend) { throw null; }`
`970`	`970`	`public virtual byte[] DeriveKeyMaterial(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey) { throw null; }`
`971`	`971`	`public virtual byte[] DeriveKeyTls(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed) { throw null; }`
	`972`	`+ public virtual byte[] DeriveRawSecretAgreement(System.Security.Cryptography.ECDiffieHellmanPublicKey otherPartyPublicKey) { throw null; }`
`972`	`973`	`public override void FromXmlString(string xmlString) { }`
`973`	`974`	`public override string ToXmlString(bool includePrivateParameters) { throw null; }`
`974`	`975`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,8 @@ public bool IsCurveValid(Oid oid)`
`21`	`21`
`22`	`22`	`public bool CanDeriveNewPublicKey => false;`
`23`	`23`
	`24`	`+ public bool SupportsRawDerivation => true;`
	`25`	`+`
`24`	`26`	`private static bool IsValueOrFriendlyNameValid(string friendlyNameOrValue)`
`25`	`27`	`{`
`26`	`28`	`if (string.IsNullOrEmpty(friendlyNameOrValue))`
Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ public bool ExplicitCurvesSupported`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`public bool CanDeriveNewPublicKey => true;`
	`26`	`+ public bool SupportsRawDerivation => PlatformDetection.IsWindows10OrLater;`
`26`	`27`
`27`	`28`	`private static bool NativeOidFriendlyNameExists(string oidFriendlyName)`
`28`	`29`	`{`