Improve exceptions thrown by MLKem and MLDsaOpenSsl when key types aren't available

vcsjones · web-flow · commit 1a52cd6e192f · 2025-06-16T18:20:33.000Z
diff --git a/src/libraries/Common/src/System/Security/Cryptography/MLDsaImplementation.Windows.cs b/src/libraries/Common/src/System/Security/Cryptography/MLDsaImplementation.Windows.cs
@@ -132,7 +132,7 @@ protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination)
         {
             if (!_hasSeed)
             {
-                throw new CryptographicException(SR.Cryptography_MLDsaNoSeed);
+                throw new CryptographicException(SR.Cryptography_PqcNoSeed);
             }
 
             ExportKey(
diff --git a/src/libraries/Common/src/System/Security/Cryptography/MLKem.cs b/src/libraries/Common/src/System/Security/Cryptography/MLKem.cs
@@ -1843,6 +1843,22 @@ private static string EncodeAsnWriterToPem(string label, AsnWriter writer, bool
 #endif
         }
 
+        private protected static void ThrowIfNoSeed(bool hasSeed)
+        {
+            if (!hasSeed)
+            {
+                throw new CryptographicException(SR.Cryptography_PqcNoSeed);
+            }
+        }
+
+        private protected static void ThrowIfNoDecapsulationKey(bool hasDecapsulationKey)
+        {
+            if (!hasDecapsulationKey)
+            {
+                throw new CryptographicException(SR.Cryptography_KemNoDecapsulationKey);
+            }
+        }
+
         private delegate TResult ExportPkcs8PrivateKeyFunc<TResult>(ReadOnlySpan<byte> pkcs8);
 
         private delegate AsnWriter WriteEncryptedPkcs8Func<TChar>(
diff --git a/src/libraries/Common/src/System/Security/Cryptography/MLKemImplementation.Windows.cs b/src/libraries/Common/src/System/Security/Cryptography/MLKemImplementation.Windows.cs
@@ -82,6 +82,9 @@ protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte
             Debug.Assert(IsSupported);
             Debug.Assert(ciphertext.Length == Algorithm.CiphertextSizeInBytes);
             Debug.Assert(sharedSecret.Length == Algorithm.SharedSecretSizeInBytes);
+
+            ThrowIfNoDecapsulationKey(_hasDecapsulationKey);
+
             uint written = Interop.BCrypt.BCryptDecapsulate(_key, ciphertext, sharedSecret, 0);
             Debug.Assert(written == (uint)sharedSecret.Length);
         }
@@ -105,12 +108,16 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared
         protected override void ExportPrivateSeedCore(Span<byte> destination)
         {
             Debug.Assert(destination.Length == Algorithm.PrivateSeedSizeInBytes);
+
+            ThrowIfNoSeed(_hasSeed);
             ExportKey(KeyBlobMagicNumber.BCRYPT_MLKEM_PRIVATE_SEED_MAGIC, destination);
         }
 
         protected override void ExportDecapsulationKeyCore(Span<byte> destination)
         {
             Debug.Assert(destination.Length == Algorithm.DecapsulationKeySizeInBytes);
+
+            ThrowIfNoDecapsulationKey(_hasDecapsulationKey);
             ExportKey(KeyBlobMagicNumber.BCRYPT_MLKEM_PRIVATE_MAGIC, destination);
         }
 
diff --git a/src/libraries/Common/tests/System/Security/Cryptography/MLKemBaseTests.cs b/src/libraries/Common/tests/System/Security/Cryptography/MLKemBaseTests.cs
@@ -48,8 +48,8 @@ public void ExportPrivateSeed_OnlyHasDecapsulationKey()
         {
             using MLKem kem = ImportDecapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512DecapsulationKey);
 
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed(
+            Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());
+            Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed(
                 new byte[MLKemAlgorithm.MLKem512.PrivateSeedSizeInBytes]));
         }
 
@@ -58,8 +58,8 @@ public void ExportPrivateSeed_OnlyHasEncapsulationKey()
         {
             using MLKem kem = ImportEncapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512EncapsulationKey);
 
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed(
+            Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());
+            Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed(
                 new byte[MLKemAlgorithm.MLKem512.PrivateSeedSizeInBytes]));
         }
 
@@ -68,8 +68,8 @@ public void ExportDecapsulationKey_OnlyHasEncapsulationKey()
         {
             using MLKem kem = ImportEncapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512EncapsulationKey);
 
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportDecapsulationKey());
-            Assert.ThrowsAny<CryptographicException>(() => kem.ExportDecapsulationKey(
+            Assert.Throws<CryptographicException>(() => kem.ExportDecapsulationKey());
+            Assert.Throws<CryptographicException>(() => kem.ExportDecapsulationKey(
                 new byte[MLKemAlgorithm.MLKem512.DecapsulationKeySizeInBytes]));
         }
 
@@ -344,7 +344,7 @@ public void ExportPkcs8PrivateKey_DecapsulationKey_Roundtrip()
                 using MLKem imported = MLKem.ImportPkcs8PrivateKey(pkcs8);
                 Assert.Equal(MLKemAlgorithm.MLKem512, imported.Algorithm);
 
-                Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());
+                Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());
                 AssertExtensions.SequenceEqual(MLKemTestData.MLKem512DecapsulationKey, kem.ExportDecapsulationKey());
             });
         }
@@ -370,7 +370,7 @@ public void ExportEncryptedPkcs8PrivateKey_DecapsulationKey_Roundtrip()
                 AssertExtensions.SequenceEqual(
                     MLKemTestData.MLKem512DecapsulationKey,
                     imported.ExportDecapsulationKey());
-                Assert.ThrowsAny<CryptographicException>(() => imported.ExportPrivateSeed());
+                Assert.Throws<CryptographicException>(() => imported.ExportPrivateSeed());
             });
         }
 
diff --git a/src/libraries/Microsoft.Bcl.Cryptography/src/Resources/Strings.resx b/src/libraries/Microsoft.Bcl.Cryptography/src/Resources/Strings.resx
@@ -168,15 +168,15 @@
   <data name="Cryptography_KemPkcs8KeyMismatch" xml:space="preserve">
     <value>The specified PKCS#8 key contains a seed that does not match the expanded key.</value>
   </data>
+  <data name="Cryptography_KemNoDecapsulationKey" xml:space="preserve">
+    <value>The current instance does not contain a decapsulation key.</value>
+  </data>
   <data name="Cryptography_KeyWrongSizeForAlgorithm" xml:space="preserve">
     <value>The specified key is not the correct size for the indicated algorithm.</value>
   </data>
   <data name="Cryptography_MLDsaNoSecretKey" xml:space="preserve">
     <value>The current instance does not contain a secret key.</value>
   </data>
-  <data name="Cryptography_MLDsaNoSeed" xml:space="preserve">
-    <value>The current instance does not contain a seed.</value>
-  </data>
   <data name="Cryptography_MLDsaPkcs8KeyMismatch" xml:space="preserve">
     <value>The specified PKCS#8 key contains a seed that does not match the expanded key.</value>
   </data>
@@ -201,6 +201,9 @@
   <data name="Cryptography_PlaintextCiphertextLengthMismatch" xml:space="preserve">
     <value>Plaintext and ciphertext must have the same length.</value>
   </data>
+  <data name="Cryptography_PqcNoSeed" xml:space="preserve">
+    <value>The current instance does not contain a seed.</value>
+  </data>
   <data name="Cryptography_UnknownAlgorithmIdentifier" xml:space="preserve">
     <value>The algorithm identified by '{0}' is unknown, not valid for the requested usage, or was not handled.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx b/src/libraries/System.Security.Cryptography/src/Resources/Strings.resx
@@ -525,6 +525,9 @@
   <data name="Cryptography_KemInvalidAlgorithmHandle" xml:space="preserve">
     <value>The specified EVP_PKEY handle is not a known ML-KEM algorithm.</value>
   </data>
+  <data name="Cryptography_KemNoDecapsulationKey" xml:space="preserve">
+    <value>The current instance does not contain a decapsulation key.</value>
+  </data>
   <data name="Cryptography_KemPkcs8KeyMismatch" xml:space="preserve">
     <value>The specified PKCS#8 key contains a seed that does not match the expanded key.</value>
   </data>
@@ -552,9 +555,6 @@
   <data name="Cryptography_MLDsaNoSecretKey" xml:space="preserve">
     <value>The current instance does not contain a secret key.</value>
   </data>
-  <data name="Cryptography_MLDsaNoSeed" xml:space="preserve">
-    <value>The current instance does not contain a seed.</value>
-  </data>
   <data name="Cryptography_MLDsaPkcs8KeyMismatch" xml:space="preserve">
     <value>The specified PKCS#8 key contains a seed that does not match the expanded key.</value>
   </data>
@@ -690,6 +690,9 @@
   <data name="Cryptography_PlaintextTooLarge" xml:space="preserve">
     <value>The specified plaintext size is too large.</value>
   </data>
+  <data name="Cryptography_PqcNoSeed" xml:space="preserve">
+    <value>The current instance does not contain a seed.</value>
+  </data>
   <data name="Cryptography_PrivateKey_DoesNotMatch" xml:space="preserve">
     <value>The provided key does not match the public key for this certificate.</value>
   </data>
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLDsaImplementation.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLDsaImplementation.OpenSsl.cs
@@ -73,7 +73,7 @@ protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination)
         {
             if (!_hasSeed)
             {
-                throw new CryptographicException(SR.Cryptography_MLDsaNoSeed);
+                throw new CryptographicException(SR.Cryptography_PqcNoSeed);
             }
 
             Interop.Crypto.MLDsaExportSeed(_key, destination);
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLDsaOpenSsl.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLDsaOpenSsl.OpenSsl.cs
@@ -81,12 +81,26 @@ protected override void ExportMLDsaPublicKeyCore(Span<byte> destination) =>
             Interop.Crypto.MLDsaExportPublicKey(_key, destination);
 
         /// <inheritdoc />
-        protected override void ExportMLDsaSecretKeyCore(Span<byte> destination) =>
+        protected override void ExportMLDsaSecretKeyCore(Span<byte> destination)
+        {
+            if (!_hasSecretKey)
+            {
+                throw new CryptographicException(SR.Cryptography_MLDsaNoSecretKey);
+            }
+
             Interop.Crypto.MLDsaExportSecretKey(_key, destination);
+        }
 
         /// <inheritdoc />
-        protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination) =>
+        protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination)
+        {
+            if (!_hasSeed)
+            {
+                throw new CryptographicException(SR.Cryptography_PqcNoSeed);
+            }
+
             Interop.Crypto.MLDsaExportSeed(_key, destination);
+        }
 
         /// <inheritdoc />
         protected override bool TryExportPkcs8PrivateKeyCore(Span<byte> destination, out int bytesWritten)
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLKemImplementation.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLKemImplementation.OpenSsl.cs
@@ -76,6 +76,7 @@ protected override void Dispose(bool disposing)
 
         protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte> sharedSecret)
         {
+            ThrowIfNoDecapsulationKey(_hasDecapsulationKey);
             Interop.Crypto.EvpKemDecapsulate(_key, ciphertext, sharedSecret);
         }
 
@@ -86,11 +87,13 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared
 
         protected override void ExportPrivateSeedCore(Span<byte> destination)
         {
+            ThrowIfNoSeed(_hasSeed);
             Interop.Crypto.EvpKemExportPrivateSeed(_key, destination);
         }
 
         protected override void ExportDecapsulationKeyCore(Span<byte> destination)
         {
+            ThrowIfNoDecapsulationKey(_hasDecapsulationKey);
             Interop.Crypto.EvpKemExportDecapsulationKey(_key, destination);
         }
 
diff --git a/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLKemOpenSsl.OpenSsl.cs b/src/libraries/System.Security.Cryptography/src/System/Security/Cryptography/MLKemOpenSsl.OpenSsl.cs
@@ -70,6 +70,9 @@ protected override void Dispose(bool disposing)
         /// <inheritdoc />
         protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte> sharedSecret)
         {
+            // This cannot use _hasDecapsulationKey here because this field only indicates if it is exportable, not if
+            // it is usable. This instance could represent an ML-KEM instance with a decapsulation key in hardware,
+            // for example.
             Interop.Crypto.EvpKemDecapsulate(_key, ciphertext, sharedSecret);
         }
 
@@ -82,12 +85,14 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared
         /// <inheritdoc />
         protected override void ExportPrivateSeedCore(Span<byte> destination)
         {
+            ThrowIfNoSeed(_hasSeed);
             Interop.Crypto.EvpKemExportPrivateSeed(_key, destination);
         }
 
         /// <inheritdoc />
         protected override void ExportDecapsulationKeyCore(Span<byte> destination)
         {
+            ThrowIfNoDecapsulationKey(_hasDecapsulationKey);
             Interop.Crypto.EvpKemExportDecapsulationKey(_key, destination);
         }
 

Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination)`
`132`	`132`	`{`
`133`	`133`	`if (!_hasSeed)`
`134`	`134`	`{`
`135`		`- throw new CryptographicException(SR.Cryptography_MLDsaNoSeed);`
	`135`	`+ throw new CryptographicException(SR.Cryptography_PqcNoSeed);`
`136`	`136`	`}`
`137`	`137`
`138`	`138`	`ExportKey(`
Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,9 @@ protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte`
`82`	`82`	`Debug.Assert(IsSupported);`
`83`	`83`	`Debug.Assert(ciphertext.Length == Algorithm.CiphertextSizeInBytes);`
`84`	`84`	`Debug.Assert(sharedSecret.Length == Algorithm.SharedSecretSizeInBytes);`
	`85`	`+`
	`86`	`+ ThrowIfNoDecapsulationKey(_hasDecapsulationKey);`
	`87`	`+`
`85`	`88`	`uint written = Interop.BCrypt.BCryptDecapsulate(_key, ciphertext, sharedSecret, 0);`
`86`	`89`	`Debug.Assert(written == (uint)sharedSecret.Length);`
`87`	`90`	`}`
`@@ -105,12 +108,16 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared`
`105`	`108`	`protected override void ExportPrivateSeedCore(Span<byte> destination)`
`106`	`109`	`{`
`107`	`110`	`Debug.Assert(destination.Length == Algorithm.PrivateSeedSizeInBytes);`
	`111`	`+`
	`112`	`+ ThrowIfNoSeed(_hasSeed);`
`108`	`113`	`ExportKey(KeyBlobMagicNumber.BCRYPT_MLKEM_PRIVATE_SEED_MAGIC, destination);`
`109`	`114`	`}`
`110`	`115`
`111`	`116`	`protected override void ExportDecapsulationKeyCore(Span<byte> destination)`
`112`	`117`	`{`
`113`	`118`	`Debug.Assert(destination.Length == Algorithm.DecapsulationKeySizeInBytes);`
	`119`	`+`
	`120`	`+ ThrowIfNoDecapsulationKey(_hasDecapsulationKey);`
`114`	`121`	`ExportKey(KeyBlobMagicNumber.BCRYPT_MLKEM_PRIVATE_MAGIC, destination);`
`115`	`122`	`}`
`116`	`123`
Original file line number	Diff line number	Diff line change
`@@ -48,8 +48,8 @@ public void ExportPrivateSeed_OnlyHasDecapsulationKey()`
`48`	`48`	`{`
`49`	`49`	`using MLKem kem = ImportDecapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512DecapsulationKey);`
`50`	`50`
`51`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());`
`52`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed(`
	`51`	`+ Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());`
	`52`	`+ Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed(`
`53`	`53`	`new byte[MLKemAlgorithm.MLKem512.PrivateSeedSizeInBytes]));`
`54`	`54`	`}`
`55`	`55`
`@@ -58,8 +58,8 @@ public void ExportPrivateSeed_OnlyHasEncapsulationKey()`
`58`	`58`	`{`
`59`	`59`	`using MLKem kem = ImportEncapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512EncapsulationKey);`
`60`	`60`
`61`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());`
`62`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed(`
	`61`	`+ Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());`
	`62`	`+ Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed(`
`63`	`63`	`new byte[MLKemAlgorithm.MLKem512.PrivateSeedSizeInBytes]));`
`64`	`64`	`}`
`65`	`65`
`@@ -68,8 +68,8 @@ public void ExportDecapsulationKey_OnlyHasEncapsulationKey()`
`68`	`68`	`{`
`69`	`69`	`using MLKem kem = ImportEncapsulationKey(MLKemAlgorithm.MLKem512, MLKemTestData.MLKem512EncapsulationKey);`
`70`	`70`
`71`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportDecapsulationKey());`
`72`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportDecapsulationKey(`
	`71`	`+ Assert.Throws<CryptographicException>(() => kem.ExportDecapsulationKey());`
	`72`	`+ Assert.Throws<CryptographicException>(() => kem.ExportDecapsulationKey(`
`73`	`73`	`new byte[MLKemAlgorithm.MLKem512.DecapsulationKeySizeInBytes]));`
`74`	`74`	`}`
`75`	`75`
`@@ -344,7 +344,7 @@ public void ExportPkcs8PrivateKey_DecapsulationKey_Roundtrip()`
`344`	`344`	`using MLKem imported = MLKem.ImportPkcs8PrivateKey(pkcs8);`
`345`	`345`	`Assert.Equal(MLKemAlgorithm.MLKem512, imported.Algorithm);`
`346`	`346`
`347`		`- Assert.ThrowsAny<CryptographicException>(() => kem.ExportPrivateSeed());`
	`347`	`+ Assert.Throws<CryptographicException>(() => kem.ExportPrivateSeed());`
`348`	`348`	`AssertExtensions.SequenceEqual(MLKemTestData.MLKem512DecapsulationKey, kem.ExportDecapsulationKey());`
`349`	`349`	`});`
`350`	`350`	`}`
`@@ -370,7 +370,7 @@ public void ExportEncryptedPkcs8PrivateKey_DecapsulationKey_Roundtrip()`
`370`	`370`	`AssertExtensions.SequenceEqual(`
`371`	`371`	`MLKemTestData.MLKem512DecapsulationKey,`
`372`	`372`	`imported.ExportDecapsulationKey());`
`373`		`- Assert.ThrowsAny<CryptographicException>(() => imported.ExportPrivateSeed());`
	`373`	`+ Assert.Throws<CryptographicException>(() => imported.ExportPrivateSeed());`
`374`	`374`	`});`
`375`	`375`	`}`
`376`	`376`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ protected override void ExportMLDsaPrivateSeedCore(Span<byte> destination)`
`73`	`73`	`{`
`74`	`74`	`if (!_hasSeed)`
`75`	`75`	`{`
`76`		`- throw new CryptographicException(SR.Cryptography_MLDsaNoSeed);`
	`76`	`+ throw new CryptographicException(SR.Cryptography_PqcNoSeed);`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`Interop.Crypto.MLDsaExportSeed(_key, destination);`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,7 @@ protected override void Dispose(bool disposing)`
`76`	`76`
`77`	`77`	`protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte> sharedSecret)`
`78`	`78`	`{`
	`79`	`+ ThrowIfNoDecapsulationKey(_hasDecapsulationKey);`
`79`	`80`	`Interop.Crypto.EvpKemDecapsulate(_key, ciphertext, sharedSecret);`
`80`	`81`	`}`
`81`	`82`
`@@ -86,11 +87,13 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared`
`86`	`87`
`87`	`88`	`protected override void ExportPrivateSeedCore(Span<byte> destination)`
`88`	`89`	`{`
	`90`	`+ ThrowIfNoSeed(_hasSeed);`
`89`	`91`	`Interop.Crypto.EvpKemExportPrivateSeed(_key, destination);`
`90`	`92`	`}`
`91`	`93`
`92`	`94`	`protected override void ExportDecapsulationKeyCore(Span<byte> destination)`
`93`	`95`	`{`
	`96`	`+ ThrowIfNoDecapsulationKey(_hasDecapsulationKey);`
`94`	`97`	`Interop.Crypto.EvpKemExportDecapsulationKey(_key, destination);`
`95`	`98`	`}`
`96`	`99`
Original file line number	Diff line number	Diff line change
`@@ -70,6 +70,9 @@ protected override void Dispose(bool disposing)`
`70`	`70`	`/// <inheritdoc />`
`71`	`71`	`protected override void DecapsulateCore(ReadOnlySpan<byte> ciphertext, Span<byte> sharedSecret)`
`72`	`72`	`{`
	`73`	`+ // This cannot use _hasDecapsulationKey here because this field only indicates if it is exportable, not if`
	`74`	`+ // it is usable. This instance could represent an ML-KEM instance with a decapsulation key in hardware,`
	`75`	`+ // for example.`
`73`	`76`	`Interop.Crypto.EvpKemDecapsulate(_key, ciphertext, sharedSecret);`
`74`	`77`	`}`
`75`	`78`
`@@ -82,12 +85,14 @@ protected override void EncapsulateCore(Span<byte> ciphertext, Span<byte> shared`
`82`	`85`	`/// <inheritdoc />`
`83`	`86`	`protected override void ExportPrivateSeedCore(Span<byte> destination)`
`84`	`87`	`{`
	`88`	`+ ThrowIfNoSeed(_hasSeed);`
`85`	`89`	`Interop.Crypto.EvpKemExportPrivateSeed(_key, destination);`
`86`	`90`	`}`
`87`	`91`
`88`	`92`	`/// <inheritdoc />`
`89`	`93`	`protected override void ExportDecapsulationKeyCore(Span<byte> destination)`
`90`	`94`	`{`
	`95`	`+ ThrowIfNoDecapsulationKey(_hasDecapsulationKey);`
`91`	`96`	`Interop.Crypto.EvpKemExportDecapsulationKey(_key, destination);`
`92`	`97`	`}`
`93`	`98`