Merge pull request #1966 from bartonjs/add-cryptography-rsa

Add System.Security.Cryptography.RSA Source and Tests

Author: stephentoub

src/Common/src/Interop/Unix/libcrypto/Interop.Bignum.cs

@@ -0,0 +1,94 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+
+using Microsoft.Win32.SafeHandles;
+
+internal static partial class Interop
+{
+    internal static partial class libcrypto
+    {
+        [DllImport(Libraries.LibCrypto)]
+        internal static extern void BN_clear_free(IntPtr a);
+
+        [DllImport(Libraries.LibCrypto)]
+        private static extern IntPtr BN_bin2bn(byte[] s, int len, IntPtr zero);
+
+        [DllImport(Libraries.LibCrypto)]
+        private static extern unsafe int BN_bn2bin(SafeBignumHandle a, byte* to);
+
+        [DllImport(Libraries.LibCrypto)]
+        private static extern int BN_num_bits(SafeBignumHandle a);
+
+        /// <summary>
+        /// Returns the number of bytes needed to export a BIGNUM.
+        /// </summary>
+        /// <remarks>This is a macro in bn.h, expanded here.</remarks>
+        private static int BN_num_bytes(SafeBignumHandle a)
+        {
+            return (BN_num_bits(a) + 7) / 8;
+        }
+
+        internal static IntPtr CreateBignumPtr(byte[] bigEndianValue)
+        {
+            if (bigEndianValue == null)
+            {
+                return IntPtr.Zero;
+            }
+
+            IntPtr handle = BN_bin2bn(bigEndianValue, bigEndianValue.Length, IntPtr.Zero);
+            return handle;
+        }
+
+        internal static SafeBignumHandle CreateBignum(byte[] bigEndianValue)
+        {
+            IntPtr handle = CreateBignumPtr(bigEndianValue);
+            return new SafeBignumHandle(handle, true);
+        }
+
+        private static byte[] ExtractBignum(IntPtr bignum, int targetSize)
+        {
+            // Given that the only reference held to bignum is an IntPtr, create an unowned SafeHandle
+            // to ensure that we don't destroy the key after extraction.
+            using (SafeBignumHandle handle = new SafeBignumHandle(bignum, ownsHandle: false))
+            {
+                return ExtractBignum(handle, targetSize);
+            }
+        }
+
+        private static unsafe byte[] ExtractBignum(SafeBignumHandle bignum, int targetSize)
+        {
+            if (bignum == null || bignum.IsInvalid)
+            {
+                return null;
+            }
+
+            int compactSize = BN_num_bytes(bignum);
+
+            if (targetSize < compactSize)
+            {
+                targetSize = compactSize;
+            }
+
+            // OpenSSL BIGNUM values do not record leading zeroes.
+            // Windows Crypt32 does.
+            //
+            // Since RSACryptoServiceProvider already checks that RSAParameters.DP.Length is
+            // exactly half of RSAParameters.Modulus.Length, we need to left-pad (big-endian)
+            // the array with zeroes.
+            int offset = targetSize - compactSize;
+
+            byte[] buf = new byte[targetSize];
+
+            fixed (byte* to = buf)
+            {
+                byte* start = to + offset;
+                BN_bn2bin(bignum, start);
+            }
+
+            return buf;
+        }
+    }
+}

src/Common/src/Interop/Unix/libcrypto/Interop.Rsa.cs

@@ -0,0 +1,119 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+
+using Microsoft.Win32.SafeHandles;
+
+// On Linux and MacOS sizeof(long)==sizeof(void*) across x86/x64
+using NativeLong=System.IntPtr;
+
+internal static partial class Interop
+{
+    internal static partial class libcrypto
+    {
+        [DllImport(Libraries.LibCrypto)]
+        internal static extern SafeRsaHandle RSA_new();
+
+        [DllImport(Libraries.LibCrypto)]
+        internal static unsafe extern SafeRsaHandle d2i_RSAPublicKey(IntPtr zero, byte** ppin, int len);
+
+        [DllImport(Libraries.LibCrypto)]
+        internal static extern void RSA_free(IntPtr rsa);
+
+        [DllImport(Libraries.LibCrypto)]
+        internal extern static int RSA_public_encrypt(int flen, byte[] from, byte[] to, SafeRsaHandle rsa, OpenSslRsaPadding padding);
+
+        [DllImport(Libraries.LibCrypto)]
+        internal extern static int RSA_private_decrypt(int flen, byte[] from, byte[] to, SafeRsaHandle rsa, OpenSslRsaPadding padding);
+
+        [DllImport(Libraries.LibCrypto)]
+        internal static extern int RSA_size(SafeRsaHandle rsa);
+
+        [DllImport(Libraries.LibCrypto)]
+        internal static extern int RSA_generate_key_ex(SafeRsaHandle rsa, int bits, SafeBignumHandle e, IntPtr zero);
+
+        internal static unsafe RSAParameters ExportRsaParameters(SafeRsaHandle key, bool includePrivateParameters)
+        {
+            Debug.Assert(
+                key != null && !key.IsInvalid,
+                "Callers should check the key is invalid and throw an exception with a message");
+
+            if (key == null || key.IsInvalid)
+            {
+                throw new CryptographicException();
+            }
+
+            RSAParameters rsaParameters;
+            bool addedRef = false;
+
+            try
+            {
+                key.DangerousAddRef(ref addedRef);
+                RSA_ST* rsaStructure = (RSA_ST*)key.DangerousGetHandle();
+
+                int modulusSize = RSA_size(key);
+
+                // RSACryptoServiceProvider expects P, DP, Q, DQ, and InverseQ to all
+                // be padded up to half the modulus size.
+                int halfModulus = modulusSize / 2;
+
+                rsaParameters = new RSAParameters
+                {
+                    Modulus = ExtractBignum(rsaStructure->n, modulusSize),
+                    Exponent = ExtractBignum(rsaStructure->e, 0),
+                };
+
+                if (includePrivateParameters)
+                {
+                    rsaParameters.D = ExtractBignum(rsaStructure->d, modulusSize);
+                    rsaParameters.P = ExtractBignum(rsaStructure->p, halfModulus);
+                    rsaParameters.DP = ExtractBignum(rsaStructure->dmp1, halfModulus);
+                    rsaParameters.Q = ExtractBignum(rsaStructure->q, halfModulus);
+                    rsaParameters.DQ = ExtractBignum(rsaStructure->dmq1, halfModulus);
+                    rsaParameters.InverseQ = ExtractBignum(rsaStructure->iqmp, halfModulus);
+                }
+            }
+            finally
+            {
+                if (addedRef)
+                {
+                    key.DangerousRelease();
+                }
+            }
+
+            return rsaParameters;
+        }
+
+        internal enum OpenSslRsaPadding
+        {
+            Invalid,
+            RSA_PKCS1_PADDING = 1,
+            RSA_SSLV23_PADDING = 2,
+            RSA_NO_PADDING = 3,
+            RSA_PKCS1_OAEP_PADDING = 4,
+            RSA_X931_PADDING = 5,
+            RSA_PKCS1_PSS_PADDING = 6,
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct RSA_ST
+        {
+            private int pad;
+            private NativeLong version;
+            private IntPtr meth;
+            private IntPtr engine;
+            public IntPtr n;
+            public IntPtr e;
+            public IntPtr d;
+            public IntPtr p;
+            public IntPtr q;
+            public IntPtr dmp1;
+            public IntPtr dmq1;
+            public IntPtr iqmp;
+        }
+    }
+}

src/Common/src/Microsoft/Win32/SafeHandles/SafeBignumHandle.Unix.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Security;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    [SecurityCritical]
+    internal sealed class SafeBignumHandle : SafeHandle
+    {
+        internal SafeBignumHandle(IntPtr handle, bool ownsHandle)
+            :  base(handle, ownsHandle)
+        {
+        }
+
+        protected override bool ReleaseHandle()
+        {
+            Interop.libcrypto.BN_clear_free(handle);
+            SetHandle(IntPtr.Zero);
+            return true;
+        }
+
+        public override bool IsInvalid
+        {
+            get { return handle == IntPtr.Zero; }
+        }
+    }
+}

src/Common/src/Microsoft/Win32/SafeHandles/SafeRsaHandle.Unix.cs

@@ -0,0 +1,30 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Security;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Win32.SafeHandles
+{
+    [SecurityCritical]
+    internal sealed class SafeRsaHandle : SafeHandle
+    {
+        private SafeRsaHandle() :
+            base(IntPtr.Zero, ownsHandle: true)
+        {
+        }
+
+        protected override bool ReleaseHandle()
+        {
+            Interop.libcrypto.RSA_free(handle);
+            SetHandle(IntPtr.Zero);
+            return true;
+        }
+
+        public override bool IsInvalid
+        {
+            get { return handle == IntPtr.Zero; }
+        }
+    }
+}

src/System.Security.Cryptography.RSA/System.Security.Cryptography.RSA.sln

@@ -0,0 +1,48 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.22911.2
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Security.Cryptography.RSA", "src\System.Security.Cryptography.RSA.csproj", "{51869113-2C21-4CD4-AA71-3F421E586E40}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Security.Cryptography.RSA.Tests", "tests\System.Security.Cryptography.RSA.Tests.csproj", "{332AC4A4-99DF-4E12-84C5-F5298A2BF241}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Linux_Debug|Any CPU = Linux_Debug|Any CPU
+		Linux_Release|Any CPU = Linux_Release|Any CPU
+		OSX_Debug|Any CPU = OSX_Debug|Any CPU
+		OSX_Release|Any CPU = OSX_Release|Any CPU
+		Windows_Debug|Any CPU = Windows_Debug|Any CPU
+		Windows_Release|Any CPU = Windows_Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Linux_Debug|Any CPU.ActiveCfg = Linux_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Linux_Debug|Any CPU.Build.0 = Linux_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Linux_Release|Any CPU.ActiveCfg = Linux_Release|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Linux_Release|Any CPU.Build.0 = Linux_Release|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.OSX_Debug|Any CPU.ActiveCfg = OSX_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.OSX_Debug|Any CPU.Build.0 = OSX_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.OSX_Release|Any CPU.ActiveCfg = OSX_Release|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.OSX_Release|Any CPU.Build.0 = OSX_Release|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Windows_Debug|Any CPU.ActiveCfg = Windows_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Windows_Debug|Any CPU.Build.0 = Windows_Debug|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Windows_Release|Any CPU.ActiveCfg = Windows_Release|Any CPU
+		{51869113-2C21-4CD4-AA71-3F421E586E40}.Windows_Release|Any CPU.Build.0 = Windows_Release|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Linux_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Linux_Debug|Any CPU.Build.0 = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Linux_Release|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Linux_Release|Any CPU.Build.0 = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.OSX_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.OSX_Debug|Any CPU.Build.0 = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.OSX_Release|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.OSX_Release|Any CPU.Build.0 = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Windows_Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Windows_Debug|Any CPU.Build.0 = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Windows_Release|Any CPU.ActiveCfg = Debug|Any CPU
+		{332AC4A4-99DF-4E12-84C5-F5298A2BF241}.Windows_Release|Any CPU.Build.0 = Debug|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

src/System.Security.Cryptography.RSA/src/Internal/Cryptography/Helpers.cs

@@ -0,0 +1,19 @@
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Diagnostics;
+using System.Security.Cryptography;
+
+namespace Internal.Cryptography
+{
+    internal static class Helpers
+    {
+        public static byte[] CloneByteArray(this byte[] src)
+        {
+            return (byte[])(src.Clone());
+        }
+    }
+}
+
+