Implement System.Security.Cryptography.RSACng

Author: Atsushi Kanamori

src/System.Security.Cryptography.Cng/src/Internal/Cryptography/SafeUnicodeStringHandle.cs

@@ -0,0 +1,41 @@
+// 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;
+
+
+namespace Internal.Cryptography
+{
+    /// <summary>
+    ///     Holds a managed string marshaled as a LPCWSTR. 
+    /// </summary>
+    internal sealed class SafeUnicodeStringHandle : SafeHandle
+    {
+        /// <summary>
+        ///     Marshal a String to a native LPCWSTR. It is permitted to pass "null" for the string.
+        /// </summary>
+        public SafeUnicodeStringHandle(string s)
+            : base(IntPtr.Zero, ownsHandle: true)
+        {
+            handle = Marshal.StringToHGlobalUni(s);
+        }
+
+        public sealed override bool IsInvalid
+        {
+            get
+            {
+                return handle == IntPtr.Zero;
+            }
+        }
+
+        protected sealed override bool ReleaseHandle()
+        {
+            Marshal.FreeHGlobal(handle);
+            return true;
+        }
+    }
+}
+
+

src/System.Security.Cryptography.Cng/src/Interop/BCrypt/Interop.AsymmetricEncryption.Types.cs

@@ -0,0 +1,57 @@
+// 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;
+
+internal partial class Interop
+{
+    /// <summary>
+    /// BCrypt types related to asymmetric encryption algorithms
+    /// </summary>
+    internal partial class BCrypt
+    {
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct BCRYPT_OAEP_PADDING_INFO
+        {
+            /// <summary>
+            ///     Null-terminated Unicode string that identifies the hashing algorithm used to create the padding.
+            /// </summary>
+            internal IntPtr pszAlgId;
+
+            /// <summary>
+            ///     Address of a buffer that contains the data used to create the padding.
+            /// </summary>
+            internal IntPtr pbLabel;
+
+            /// <summary>
+            ///     Number of bytes in the pbLabel buffer.
+            /// </summary>
+            internal int cbLabel;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct BCRYPT_PKCS1_PADDING_INFO
+        {
+            /// <summary>
+            ///     Null-terminated Unicode string that identifies the hashing algorithm used to create the padding.
+            /// </summary>
+            internal IntPtr pszAlgId;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct BCRYPT_PSS_PADDING_INFO
+        {
+            /// <summary>
+            ///     Null-terminated Unicode string that identifies the hashing algorithm used to create the padding.
+            /// </summary>
+            internal IntPtr pszAlgId;
+
+            /// <summary>
+            ///     The size, in bytes, of the random salt to use for the padding.
+            /// </summary>
+            internal int cbSalt;
+        }
+    }
+}

src/System.Security.Cryptography.Cng/src/Interop/BCrypt/Interop.Blobs.cs

@@ -0,0 +1,58 @@
+// 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;
+
+internal partial class Interop
+{
+    //
+    // These structures define the layout of CNG key blobs passed to NCryptImportKey 
+    //
+    internal partial class BCrypt
+    {
+        /// <summary>
+        ///     Magic numbers identifying blob types
+        /// </summary>
+        internal enum KeyBlobMagicNumber : int
+        {
+            BCRYPT_ECDH_PUBLIC_P256_MAGIC = 0x314B4345,
+            BCRYPT_ECDH_PUBLIC_P384_MAGIC = 0x334B4345,
+            BCRYPT_ECDH_PUBLIC_P521_MAGIC = 0x354B4345,
+            BCRYPT_ECDSA_PUBLIC_P256_MAGIC = 0x31534345,
+            BCRYPT_ECDSA_PUBLIC_P384_MAGIC = 0x33534345,
+            BCRYPT_ECDSA_PUBLIC_P521_MAGIC = 0x35534345,
+            BCRYPT_RSAPUBLIC_MAGIC = 0x31415352,
+            BCRYPT_RSAPRIVATE_MAGIC = 0x32415352,
+            BCRYPT_RSAFULLPRIVATE_MAGIC = 0x33415352,   
+            BCRYPT_KEY_DATA_BLOB_MAGIC = 0x4d42444b,
+        }
+
+
+        /// <summary>
+        ///     Well known key blob types
+        /// </summary>
+        internal static class KeyBlobType
+        {
+            internal const string BCRYPT_RSAFULLPRIVATE_BLOB = "RSAFULLPRIVATEBLOB";    
+            internal const string BCRYPT_RSAPRIVATE_BLOB = "RSAPRIVATEBLOB";            
+            internal const string BCRYPT_PUBLIC_KEY_BLOB = "RSAPUBLICBLOB";             
+        }
+
+
+        /// <summary>
+        ///     The BCRYPT_RSAKEY_BLOB structure is used as a header for an RSA public key or private key BLOB in memory.
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct BCRYPT_RSAKEY_BLOB
+        {
+            internal KeyBlobMagicNumber Magic;
+            internal int BitLength;
+            internal int cbPublicExp;
+            internal int cbModulus;
+            internal int cbPrime1;
+            internal int cbPrime2;
+        }
+    }
+}

src/System.Security.Cryptography.Cng/src/Interop/NCrypt/NCrypt.cs

@@ -44,6 +44,18 @@ internal static partial class NCrypt
         [DllImport(Interop.Libraries.NCrypt, CharSet = CharSet.Unicode)]
         internal static extern ErrorCode NCryptFinalizeKey(SafeNCryptKeyHandle hKey, int dwFlags);
 
+        [DllImport(Interop.Libraries.NCrypt, CharSet = CharSet.Unicode)]
+        internal static unsafe extern ErrorCode NCryptEncrypt(SafeNCryptKeyHandle hKey, [In] byte[] pbInput, int cbInput, void* pPaddingInfo, [Out] byte[] pbOutput, int cbOutput, out int pcbResult, AsymmetricPaddingMode dwFlags);
+
+        [DllImport(Interop.Libraries.NCrypt, CharSet = CharSet.Unicode)]
+        internal static unsafe extern ErrorCode NCryptDecrypt(SafeNCryptKeyHandle hKey, [In] byte[] pbInput, int cbInput, void* pPaddingInfo, [Out] byte[] pbOutput, int cbOutput, out int pcbResult, AsymmetricPaddingMode dwFlags);
+
+        [DllImport(Interop.Libraries.NCrypt, CharSet = CharSet.Unicode)]
+        internal static unsafe extern ErrorCode NCryptSignHash(SafeNCryptKeyHandle hKey, void* pPaddingInfo, [In] byte[] pbHashValue, int cbHashValue, [Out] byte[] pbSignature, int cbSignature, out int pcbResult, AsymmetricPaddingMode dwFlags);
+
+        [DllImport(Interop.Libraries.NCrypt, CharSet = CharSet.Unicode)]
+        internal static unsafe extern ErrorCode NCryptVerifySignature(SafeNCryptKeyHandle hKey, void *pPaddingInfo, [In] byte[] pbHashValue, int cbHashValue, [In] byte[] pbSignature, int cbSignature, AsymmetricPaddingMode dwFlags);
+
         /// <summary>
         ///     Result codes from NCrypt APIs
         /// </summary>
@@ -68,5 +80,14 @@ internal struct NCRYPT_UI_POLICY
             public IntPtr pszFriendlyName;
             public IntPtr pszDescription;
         }
+
+        internal enum AsymmetricPaddingMode : int
+        {
+            NCRYPT_NO_PADDING_FLAG = 0x00000001,
+            NCRYPT_PAD_PKCS1_FLAG = 0x00000002,    // NCryptEncrypt/Decrypt or NCryptSignHash/VerifySignature
+            NCRYPT_PAD_OAEP_FLAG = 0x00000004,     // NCryptEncrypt/Decrypt
+            NCRYPT_PAD_PSS_FLAG = 0x00000008,      // NCryptSignHash/VerifySignature
+        }
     }
-}
+}
+ 

src/System.Security.Cryptography.Cng/src/Resources/Strings.resx

@@ -132,6 +132,9 @@
   <data name="Cryptography_ArgRSAaRequiresRSAKey" xml:space="preserve">
     <value>Keys used with the RSACng algorithm must have an algorithm group of RSA.</value>
   </data>
+  <data name="Cryptography_HashAlgorithmNameNullOrEmpty" xml:space="preserve">
+    <value>The hash algorithm name cannot be null or empty.</value>
+  </data>
   <data name="Cryptography_InvalidAlgorithmGroup" xml:space="preserve">
     <value>The algorithm group '{0}' is invalid.</value>
   </data>
@@ -183,4 +186,7 @@
   <data name="WorkInProgress" xml:space="preserve">
     <value>WorkInProgress.</value>
   </data>
+  <data name="WorkInProgress_UnsupportedHash" xml:space="preserve">
+    <value>Unsupported hash algorithm. RSACng currently supports only MD5, SHA1, SHA256, SHA384 and SHA512.</value>
+  </data>
 </root>

src/System.Security.Cryptography.Cng/src/System.Security.Cryptography.Cng.csproj

@@ -52,15 +52,23 @@
      <Compile Include="System\Security\Cryptography\CngUIPolicy.cs" />
      <Compile Include="System\Security\Cryptography\CngUIProtectionLevels.cs" />
      <Compile Include="System\Security\Cryptography\RSACng.cs" />
+     <Compile Include="System\Security\Cryptography\RSACng.EncryptDecrypt.cs" />
+     <Compile Include="System\Security\Cryptography\RSACng.HashData.cs" />
+     <Compile Include="System\Security\Cryptography\RSACng.ImportExport.cs" />
+     <Compile Include="System\Security\Cryptography\RSACng.Key.cs" />
+     <Compile Include="System\Security\Cryptography\RSACng.SignVerify.cs" />
 
      <Compile Include="Microsoft\Win32\SafeHandles\NCryptSafeHandles.cs" />
 
      <Compile Include="Internal\Cryptography\Helpers.cs" />
      <Compile Include="Internal\Cryptography\KeyPropertyName.cs" />
      <Compile Include="Internal\Cryptography\ProviderPropertyName.cs" />
+     <Compile Include="Internal\Cryptography\SafeUnicodeStringHandle.cs" />
 
      <Compile Include="Interop\Interop.Libraries.cs" />
      <Compile Include="Interop\NCrypt\NCrypt.cs" />
+     <Compile Include="Interop\BCrypt\Interop.Blobs.cs" />
+     <Compile Include="Interop\BCrypt\Interop.AsymmetricEncryption.Types.cs" />
 
   </ItemGroup>
   <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), dir.targets))\dir.targets" />

src/System.Security.Cryptography.Cng/src/System/Security/Cryptography/RSACng.EncryptDecrypt.cs

@@ -0,0 +1,106 @@
+// 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.IO;
+
+using Microsoft.Win32.SafeHandles;
+
+using Internal.Cryptography;
+
+using ErrorCode = Interop.NCrypt.ErrorCode;
+using AsymmetricPaddingMode = Interop.NCrypt.AsymmetricPaddingMode;
+using BCRYPT_OAEP_PADDING_INFO = Interop.BCrypt.BCRYPT_OAEP_PADDING_INFO;
+
+namespace System.Security.Cryptography
+{
+    public sealed partial class RSACng : RSA
+    {
+        /// <summary>
+        ///     Encrypts data using the public key.
+        /// </summary>
+        public override byte[] Encrypt(byte[] data, RSAEncryptionPadding padding)
+        {
+            unsafe
+            {
+                return EncryptOrDecrypt(data, padding, Interop.NCrypt.NCryptEncrypt);
+            }
+        }
+
+        /// <summary>
+        ///     Decrypts data using the private key.
+        /// </summary>
+        public override byte[] Decrypt(byte[] data, RSAEncryptionPadding padding)
+        {
+            unsafe
+            {
+                return EncryptOrDecrypt(data, padding, Interop.NCrypt.NCryptDecrypt);
+            }
+        }
+
+        //
+        // Conveniently, Encrypt() and Decrypt() are identical save for the actual P/Invoke call to CNG. Thus, both
+        // api's invoke this common helper with the "transform" parameter determining whether encryption or decryption is done.
+        //
+        private byte[] EncryptOrDecrypt(byte[] data, RSAEncryptionPadding padding, EncryptOrDecryptAction encryptOrDecrypt)
+        {
+            if (data == null)
+                throw new ArgumentNullException("data");
+
+            if (padding == null)
+                throw new ArgumentNullException("padding");
+
+            unsafe
+            {
+                SafeNCryptKeyHandle keyHandle = Key.Handle;
+                switch (padding.Mode)
+                {
+                    case RSAEncryptionPaddingMode.Pkcs1:
+                        return EncryptOrDecrypt(keyHandle, data, AsymmetricPaddingMode.NCRYPT_PAD_PKCS1_FLAG, null, encryptOrDecrypt);
+
+                    case RSAEncryptionPaddingMode.Oaep:
+                        {
+                            using (SafeUnicodeStringHandle safeHashAlgorithmName = new SafeUnicodeStringHandle(padding.OaepHashAlgorithm.Name))
+                            {
+                                BCRYPT_OAEP_PADDING_INFO paddingInfo = new BCRYPT_OAEP_PADDING_INFO()
+                                {
+                                    pszAlgId = safeHashAlgorithmName.DangerousGetHandle(),
+
+                                    // It would nice to put randomized data here but RSAEncryptionPadding does not at this point provide support for this.
+                                    pbLabel = IntPtr.Zero,
+                                    cbLabel = 0, 
+                                };
+                                return EncryptOrDecrypt(keyHandle, data, AsymmetricPaddingMode.NCRYPT_PAD_OAEP_FLAG, &paddingInfo, encryptOrDecrypt);
+                            }
+                        }
+
+                    default:
+                        throw new CryptographicException(SR.Cryptography_UnsupportedPaddingMode);
+                }
+            }
+        }
+
+        //
+        // Now that the padding mode and information have been marshaled to their native counterparts, perform the encryption or decryption.
+        //
+        private static unsafe byte[] EncryptOrDecrypt(SafeNCryptKeyHandle key, byte[] input, AsymmetricPaddingMode paddingMode, void* paddingInfo, EncryptOrDecryptAction encryptOrDecrypt)
+        {
+            int numBytesNeeded;
+            ErrorCode errorCode = encryptOrDecrypt(key, input, input.Length, paddingInfo, null, 0, out numBytesNeeded, paddingMode);
+            if (errorCode != ErrorCode.ERROR_SUCCESS)
+                throw errorCode.ToCryptographicException();
+
+            byte[] output = new byte[numBytesNeeded];
+            errorCode = encryptOrDecrypt(key, input, input.Length, paddingInfo, output, numBytesNeeded, out numBytesNeeded, paddingMode);
+            if (errorCode != ErrorCode.ERROR_SUCCESS)
+                throw errorCode.ToCryptographicException();
+
+            return output;
+        }
+
+        // Delegate binds to either NCryptEncrypt() or NCryptDecrypt() depending on which api was called.
+        private unsafe delegate ErrorCode EncryptOrDecryptAction(SafeNCryptKeyHandle hKey, byte[] pbInput, int cbInput, void* pPaddingInfo, byte[] pbOutput, int cbOutput, out int pcbResult, AsymmetricPaddingMode dwFlags);
+    }
+}
+