Port ECDiffieHellman to .NET Core

This brings the ECDiffieHellman class as-is from .NET Framework (last edited
for net47) to System.Security.Cryptography.Algorithms, and the
ECDiffieHellmanCng class as-is to System.Security.Cryptography.Cng, and adds
ECDiffieHellmanOpenSsl to System.Security.Cryptography.OpenSsl.

A fair amount of this change is factoring out ECDSA code to general ECC code
for each of the platforms.

Since there isn't obvious value in having public ECDiffieHellmanPublicKey
derived types, ECDiffieHellmanOpenSslPublicKey is not public.

This PR also fixed some cases where a CryptographicException was thrown instead
of a WindowsCryptographicException, because they got noticed during this PR.

Author: bartonjs

src/Common/src/Interop/OSX/System.Security.Cryptography.Native.Apple/Interop.KeyAgree.cs

@@ -0,0 +1,61 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Security.Cryptography.Apple;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class AppleCrypto
+    {
+        [DllImport(Libraries.AppleCryptoNative)]
+        private static extern int AppleCryptoNative_EcdhKeyAgree(
+            SafeSecKeyRefHandle privateKey,
+            SafeSecKeyRefHandle publicKey,
+            out SafeCFDataHandle cfDataOut,
+            out SafeCFErrorHandle cfErrorOut);
+
+        internal static byte[] EcdhKeyAgree(
+            SafeSecKeyRefHandle privateKey,
+            SafeSecKeyRefHandle publicKey,
+            Span<byte> opportunisticDestination,
+            out int bytesWritten)
+        {
+            const int Success = 1;
+            const int kErrorSeeError = -2;
+
+            SafeCFDataHandle data;
+            SafeCFErrorHandle error;
+
+            int status = AppleCryptoNative_EcdhKeyAgree(privateKey, publicKey, out data, out error);
+
+            using (data)
+            using (error)
+            {
+                if (status == kErrorSeeError)
+                {
+                    throw CreateExceptionForCFError(error);
+                }
+
+                if (status == Success && !data.IsInvalid)
+                {
+                    if (CoreFoundation.TryCFWriteData(data, opportunisticDestination, out bytesWritten))
+                    {
+                        return null;
+                    }
+
+                    bytesWritten = 0;
+                    return CoreFoundation.CFGetData(data);
+                }
+
+                Debug.Fail($"Unexpected status ({status})");
+                throw new CryptographicException();
+            }
+        }
+    }
+}

src/Common/src/Interop/Unix/System.Security.Cryptography.Native/Interop.EvpPkey.Ecdh.cs

@@ -0,0 +1,43 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class Crypto
+    {
+        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpPKeyCtxCreate")]
+        internal static extern SafeEvpPKeyCtxHandle EvpPKeyCtxCreate(SafeEvpPKeyHandle pkey, SafeEvpPKeyHandle peerkey, out uint secretLength);
+
+        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpPKeyDeriveSecretAgreement")]
+        private static extern int EvpPKeyDeriveSecretAgreement(
+            ref byte secret,
+            uint secretLength,
+            SafeEvpPKeyCtxHandle ctx);
+
+        [DllImport(Libraries.CryptoNative, EntryPoint = "CryptoNative_EvpPKeyCtxDestroy")]
+        internal static extern void EvpPKeyCtxDestroy(IntPtr ctx);
+
+        internal static void EvpPKeyDeriveSecretAgreement(SafeEvpPKeyCtxHandle ctx, Span<byte> destination)
+        {
+            Debug.Assert(ctx != null);
+            Debug.Assert(!ctx.IsInvalid);
+
+            int ret = EvpPKeyDeriveSecretAgreement(
+                ref MemoryMarshal.GetReference(destination),
+                (uint)destination.Length,
+                ctx);
+
+            if (ret != 1)
+            {
+                throw CreateOpenSslCryptographicException();
+            }
+        }
+    }
+}

src/Common/src/Interop/Windows/BCrypt/Interop.CreateCryptographicException.cs

@@ -3,7 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
-using System.Security.Cryptography;
+using Internal.Cryptography;
 
 internal partial class Interop
 {
@@ -12,7 +12,7 @@ internal partial class BCrypt
         internal static Exception CreateCryptographicException(NTSTATUS ntStatus)
         {
             int hr = unchecked((int)ntStatus) | 0x01000000;
-            return new CryptographicException(hr);
+            return hr.ToCryptographicException();
         }
     }
 }

src/Common/src/Interop/Windows/NCrypt/Interop.NCryptBuffer.cs

@@ -0,0 +1,42 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.InteropServices;
+
+internal static partial class Interop
+{
+    internal static partial class NCrypt
+    {
+        /// <summary>
+        ///     Types of NCryptBuffers
+        /// </summary>
+        internal enum BufferType
+        {
+            KdfHashAlgorithm = 0x00000000,              // KDF_HASH_ALGORITHM
+            KdfSecretPrepend = 0x00000001,              // KDF_SECRET_PREPEND
+            KdfSecretAppend = 0x00000002,               // KDF_SECRET_APPEND
+            KdfHmacKey = 0x00000003,                    // KDF_HMAC_KEY
+            KdfTlsLabel = 0x00000004,                   // KDF_TLS_PRF_LABEL
+            KdfTlsSeed = 0x00000005                     // KDF_TLS_PRF_SEED
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct NCryptBuffer
+        {
+            public int cbBuffer;
+            public BufferType BufferType;
+            public IntPtr pvBuffer;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct NCryptBufferDesc
+        {
+            public int ulVersion;
+            public int cBuffers;
+            public IntPtr pBuffers;         // NCryptBuffer[cBuffers]
+        }
+    }
+}
+