Exemplo n.º 1
0
        public BasicSymmetricCipherCsp(int algId, CipherMode cipherMode, int blockSizeInBytes, byte[] key, bool addNoSaltFlag, byte[]?iv, bool encrypting, int feedbackSize, int paddingSizeInBytes)
            : base(cipherMode.GetCipherIv(iv), blockSizeInBytes, paddingSizeInBytes)
        {
            _encrypting = encrypting;

            _hProvider = AcquireSafeProviderHandle();
            _hKey      = ImportCspBlob(_hProvider, algId, key, addNoSaltFlag);

            SetKeyParameter(_hKey, CryptGetKeyParamQueryType.KP_MODE, (int)cipherMode);
            if (cipherMode == CipherMode.CFB)
            {
                SetKeyParameter(_hKey, CryptGetKeyParamQueryType.KP_MODE_BITS, feedbackSize);
            }

            byte[]? currentIv = cipherMode.GetCipherIv(iv);
            if (currentIv != null)
            {
                SetKeyParameter(_hKey, CryptGetKeyParamQueryType.KP_IV, currentIv);
            }

            if (algId == CapiHelper.CALG_RC2)
            {
                SetKeyParameter(_hKey, CryptGetKeyParamQueryType.KP_EFFECTIVE_KEYLEN, key.Length * 8);
            }
        }
Exemplo n.º 2
0
        public DSACryptoServiceProvider(int dwKeySize, CspParameters?parameters)
        {
            if (dwKeySize < 0)
            {
                throw new ArgumentOutOfRangeException(nameof(dwKeySize), SR.ArgumentOutOfRange_NeedNonNegNum);
            }

            _parameters = CapiHelper.SaveCspParameters(
                CapiHelper.CspAlgorithmType.Dss,
                parameters,
                s_useMachineKeyStore,
                out _randomKeyContainer);

            _keySize = dwKeySize;
            _sha1    = SHA1.Create();

            // If this is not a random container we generate, create it eagerly
            // in the constructor so we can report any errors now.
            if (!_randomKeyContainer)
            {
                // Force-read the SafeKeyHandle property, which will summon it into existence.
                SafeCapiKeyHandle localHandle = SafeKeyHandle;
                Debug.Assert(localHandle != null);
            }
        }
Exemplo n.º 3
0
        internal static void SetKeyParameter(SafeCapiKeyHandle key, KeyParameter parameter, int value)
        {
            Contract.Requires(key != null);
            Contract.Requires(parameter == KeyParameter.Mode || parameter == KeyParameter.ModeBits);

            SetKeyParameter(key, parameter, BitConverter.GetBytes(value));
        }
 public override ICryptoTransform CreateEncryptor(byte[] key, byte[] iv)
 {
     if (key == null)
     {
         throw new ArgumentNullException("key");
     }
     if (!base.ValidKeySize(key.Length * 8))
     {
         throw new ArgumentException(System.SR.GetString("Cryptography_InvalidKeySize"), "key");
     }
     if ((iv != null) && ((iv.Length * 8) != base.BlockSizeValue))
     {
         throw new ArgumentException(System.SR.GetString("Cryptography_InvalidIVSize"), "iv");
     }
     byte[] buffer  = (byte[])key.Clone();
     byte[] buffer2 = null;
     if (iv != null)
     {
         buffer2 = (byte[])iv.Clone();
     }
     using (SafeCapiKeyHandle handle = CapiNative.ImportSymmetricKey(this.m_cspHandle, GetAlgorithmId(buffer.Length * 8), buffer))
     {
         return(this.CreateEncryptor(handle, buffer2));
     }
 }
Exemplo n.º 5
0
 public static extern bool CryptEncrypt(SafeCapiKeyHandle hKey,
                                        SafeCapiHashHandle hHash,
                                        [MarshalAs(UnmanagedType.Bool)] bool Final,
                                        int dwFlags,
                                        IntPtr pbData, // BYTE *
                                        [In, Out] ref int pdwDataLen,
                                        int dwBufLen);
Exemplo n.º 6
0
        private static SafeCapiKeyHandle SetupKey(SafeCapiKeyHandle key, byte[] iv, CipherMode cipherMode, int feedbackSize)
        {
            Contract.Requires(key != null);
            Contract.Requires(cipherMode == CipherMode.ECB || iv != null);
            Contract.Requires(0 <= feedbackSize);
            Contract.Ensures(Contract.Result <SafeCapiKeyHandle>() != null &&
                             !Contract.Result <SafeCapiKeyHandle>().IsInvalid&&
                             !Contract.Result <SafeCapiKeyHandle>().IsClosed);

            // Make a copy of the key so that we don't modify the properties of the caller's copy
            SafeCapiKeyHandle encryptionKey = key.Duplicate();

            // Setup the cipher mode first
            CapiNative.SetKeyParameter(encryptionKey, CapiNative.KeyParameter.Mode, (int)cipherMode);

            // If we're not in ECB mode then setup the IV
            if (cipherMode != CipherMode.ECB)
            {
                CapiNative.SetKeyParameter(encryptionKey, CapiNative.KeyParameter.IV, iv);
            }

            // OFB and CFB require a feedback loop size
            if (cipherMode == CipherMode.CFB || cipherMode == CipherMode.OFB)
            {
                CapiNative.SetKeyParameter(encryptionKey, CapiNative.KeyParameter.ModeBits, feedbackSize);
            }

            return(encryptionKey);
        }
Exemplo n.º 7
0
 internal static void SetKeyParameter(SafeCapiKeyHandle key, KeyParameter parameter, byte[] value)
 {
     if (!UnsafeNativeMethods.CryptSetKeyParam(key, parameter, value, 0))
     {
         throw new CryptographicException(Marshal.GetLastWin32Error());
     }
 }
        public override ICryptoTransform CreateEncryptor(byte[] key, byte[] iv)
        {
            Contract.Ensures(Contract.Result <ICryptoTransform>() != null);

            if (key == null)
            {
                throw new ArgumentNullException("key");
            }
            if (!ValidKeySize(key.Length * 8))
            {
                throw new ArgumentException(SR.GetString(SR.Cryptography_InvalidKeySize), "key");
            }
            if (iv != null && iv.Length * 8 != BlockSizeValue)
            {
                throw new ArgumentException(SR.GetString(SR.Cryptography_InvalidIVSize), "iv");
            }

            byte[] keyCopy = (byte[])key.Clone();
            byte[] ivCopy  = null;
            if (iv != null)
            {
                ivCopy = (byte[])iv.Clone();
            }

            using (SafeCapiKeyHandle importedKey = CapiNative.ImportSymmetricKey(m_cspHandle, GetAlgorithmId(keyCopy.Length * 8), keyCopy)) {
                return(CreateEncryptor(importedKey, ivCopy));
            }
        }
        public override void GenerateKey()
        {
            Contract.Ensures(m_key != null && !m_key.IsInvalid & !m_key.IsClosed);
            Contract.Assert(m_cspHandle != null);

            SafeCapiKeyHandle key = null;

            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                if (!CapiNative.UnsafeNativeMethods.CryptGenKey(m_cspHandle,
                                                                GetAlgorithmId(KeySizeValue),
                                                                CapiNative.KeyFlags.Exportable,
                                                                out key))
                {
                    throw new CryptographicException(Marshal.GetLastWin32Error());
                }
            }
            finally {
                if (key != null && !key.IsInvalid)
                {
                    key.SetParentCsp(m_cspHandle);
                }
            }

            if (m_key != null)
            {
                m_key.Dispose();
            }

            m_key = key;
        }
Exemplo n.º 10
0
        internal static unsafe SafeCapiKeyHandle ImportSymmetricKey(SafeCspHandle provider, AlgorithmId algorithm, byte[] key)
        {
            int num = (Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int))) + key.Length;

            byte[] dst = new byte[num];
            fixed(byte *numRef = dst)
            {
                BLOBHEADER *blobheaderPtr = (BLOBHEADER *)numRef;

                blobheaderPtr->bType    = KeyBlobType.PlainText;
                blobheaderPtr->bVersion = 2;
                blobheaderPtr->reserved = 0;
                blobheaderPtr->aiKeyAlg = algorithm;
                int *numPtr = (int *)(numRef + Marshal.SizeOf(blobheaderPtr[0]));

                numPtr[0] = key.Length;
            }

            Buffer.BlockCopy(key, 0, dst, Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)), key.Length);
            SafeCapiKeyHandle phKey = null;

            if (!UnsafeNativeMethods.CryptImportKey(provider, dst, dst.Length, SafeCapiKeyHandle.InvalidHandle, KeyFlags.Exportable, out phKey))
            {
                throw new CryptographicException(Marshal.GetLastWin32Error());
            }
            return(phKey);
        }
Exemplo n.º 11
0
        internal static byte[] ExportSymmetricKey(SafeCapiKeyHandle key)
        {
            Contract.Requires(key != null);
            Contract.Ensures(Contract.Result <byte[]>() != null && Contract.Result <byte[]>().Length > 0);

            //
            // Figure out how big the key blob is, and export it
            //

            int keySize = 0;

            if (!UnsafeNativeMethods.CryptExportKey(key,
                                                    SafeCapiKeyHandle.InvalidHandle,
                                                    (int)KeyBlobType.PlainText,
                                                    0,
                                                    null,
                                                    ref keySize))
            {
                int error = Marshal.GetLastWin32Error();

                if (error != (int)ErrorCode.MoreData)
                {
                    throw new CryptographicException(error);
                }
            }

            byte[] keyBlob = new byte[keySize];
            if (!UnsafeNativeMethods.CryptExportKey(key,
                                                    SafeCapiKeyHandle.InvalidHandle,
                                                    (int)KeyBlobType.PlainText,
                                                    0,
                                                    keyBlob,
                                                    ref keySize))
            {
                throw new CryptographicException(Marshal.GetLastWin32Error());
            }

            //
            // Strip the headers from the key to access the raw data
            //
            // A PLAINTEXTBLOB is laid out as follows:
            //   BLOBHEADER hdr
            //   DWORD      cbKeySize
            //   BYTE       rbgKeyData[]
            //

            int keyDataOffset = Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int));

            Debug.Assert(keyBlob.Length > keyDataOffset, "Key blob is in an unexpected format.");

            int keyLength = BitConverter.ToInt32(keyBlob, Marshal.SizeOf(typeof(BLOBHEADER)));

            Debug.Assert(keyLength > 0, "Unexpected key length.");
            Debug.Assert(keyBlob.Length >= keyDataOffset + keyLength, "Key blob is in an unexpected format.");

            byte[] keyData = new byte[keyLength];
            Buffer.BlockCopy(keyBlob, keyDataOffset, keyData, 0, keyData.Length);
            return(keyData);
        }
 public CapiSymmetricAlgorithm(int blockSize, int feedbackSize, SafeCspHandle provider, SafeCapiKeyHandle key, byte[] iv, CipherMode cipherMode, PaddingMode paddingMode, EncryptionMode encryptionMode)
 {
     this.m_blockSize      = blockSize;
     this.m_encryptionMode = encryptionMode;
     this.m_paddingMode    = paddingMode;
     this.m_provider       = provider.Duplicate();
     this.m_key            = SetupKey(key, ProcessIV(iv, blockSize, cipherMode), cipherMode, feedbackSize);
 }
Exemplo n.º 13
0
        internal static void SetKeyParameter(SafeCapiKeyHandle key, KeyParameter parameter, byte[] value)
        {
            Contract.Requires(key != null && !key.IsInvalid && !key.IsClosed);
            Contract.Requires(value != null);

            if (!UnsafeNativeMethods.CryptSetKeyParam(key, parameter, value, 0))
            {
                throw new CryptographicException(Marshal.GetLastWin32Error());
            }
        }
        public override void GenerateKey()
        {
            SafeCapiKeyHandle phKey = null;

            if (!CapiNative.UnsafeNativeMethods.CryptGenKey(this.m_cspHandle, GetAlgorithmId(base.KeySizeValue), CapiNative.KeyFlags.Exportable, out phKey))
            {
                throw new CryptographicException(Marshal.GetLastWin32Error());
            }
            if (this.m_key != null)
            {
                this.m_key.Dispose();
            }
            this.m_key = phKey;
        }
        private ICryptoTransform CreateEncryptor(SafeCapiKeyHandle key, byte[] iv)
        {
            Contract.Requires(key != null);
            Contract.Ensures(Contract.Result <ICryptoTransform>() != null);

            return(new CapiSymmetricAlgorithm(BlockSizeValue,
                                              FeedbackSizeValue,
                                              m_cspHandle,
                                              key,
                                              iv,
                                              Mode,
                                              PaddingValue,
                                              EncryptionMode.Encrypt));
        }
        private static SafeCapiKeyHandle SetupKey(SafeCapiKeyHandle key, byte[] iv, CipherMode cipherMode, int feedbackSize)
        {
            SafeCapiKeyHandle handle = key.Duplicate();

            CapiNative.SetKeyParameter(handle, CapiNative.KeyParameter.Mode, (int)cipherMode);
            if (cipherMode != CipherMode.ECB)
            {
                CapiNative.SetKeyParameter(handle, CapiNative.KeyParameter.IV, iv);
            }
            if ((cipherMode == CipherMode.CFB) || (cipherMode == CipherMode.OFB))
            {
                CapiNative.SetKeyParameter(handle, CapiNative.KeyParameter.ModeBits, feedbackSize);
            }
            return(handle);
        }
Exemplo n.º 17
0
        public CapiSymmetricAlgorithm(int blockSize,
                                      int feedbackSize,
                                      SafeCspHandle provider,
                                      SafeCapiKeyHandle key,
                                      byte[] iv,
                                      CipherMode cipherMode,
                                      PaddingMode paddingMode,
                                      EncryptionMode encryptionMode)
        {
            Contract.Requires(0 < blockSize && blockSize % 8 == 0);
            Contract.Requires(0 <= feedbackSize);
            Contract.Requires(provider != null && !provider.IsInvalid && !provider.IsClosed);
            Contract.Requires(key != null && !key.IsInvalid && !key.IsClosed);
            Contract.Ensures(m_provider != null && !m_provider.IsInvalid && !m_provider.IsClosed);

            m_blockSize      = blockSize;
            m_encryptionMode = encryptionMode;
            m_paddingMode    = paddingMode;
            m_provider       = provider.Duplicate();
            m_key            = SetupKey(key, ProcessIV(iv, blockSize, cipherMode), cipherMode, feedbackSize);
        }
Exemplo n.º 18
0
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                SafeCapiKeyHandle hKey = _hKey;
                if (hKey != null)
                {
                    _hKey = null !;
                    hKey.Dispose();
                }

                SafeProvHandle hProvider = _hProvider;
                if (hProvider != null)
                {
                    _hProvider = null !;
                    hProvider.Dispose();
                }
            }

            base.Dispose(disposing);
        }
Exemplo n.º 19
0
        internal static byte[] ExportSymmetricKey(SafeCapiKeyHandle key)
        {
            int pdwDataLen = 0;

            if (!UnsafeNativeMethods.CryptExportKey(key, SafeCapiKeyHandle.InvalidHandle, 8, 0, null, ref pdwDataLen))
            {
                int hr = Marshal.GetLastWin32Error();
                if (hr != 0xea)
                {
                    throw new CryptographicException(hr);
                }
            }
            byte[] pbData = new byte[pdwDataLen];
            if (!UnsafeNativeMethods.CryptExportKey(key, SafeCapiKeyHandle.InvalidHandle, 8, 0, pbData, ref pdwDataLen))
            {
                throw new CryptographicException(Marshal.GetLastWin32Error());
            }
            int srcOffset = Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int));

            byte[] dst = new byte[BitConverter.ToInt32(pbData, Marshal.SizeOf(typeof(BLOBHEADER)))];
            Buffer.BlockCopy(pbData, srcOffset, dst, 0, dst.Length);
            return(dst);
        }
Exemplo n.º 20
0
        private RSACryptoServiceProvider(int keySize, CspParameters?parameters, bool useDefaultKeySize)
        {
            if (keySize < 0)
            {
                throw new ArgumentOutOfRangeException("dwKeySize", "ArgumentOutOfRange_NeedNonNegNum");
            }

            _parameters = CapiHelper.SaveCspParameters(
                CapiHelper.CspAlgorithmType.Rsa,
                parameters,
                s_useMachineKeyStore,
                out _randomKeyContainer);

            _keySize = useDefaultKeySize ? 1024 : keySize;

            // If this is not a random container we generate, create it eagerly
            // in the constructor so we can report any errors now.
            if (!_randomKeyContainer)
            {
                // Force-read the SafeKeyHandle property, which will summon it into existence.
                SafeCapiKeyHandle localHandle = SafeKeyHandle;
                Debug.Assert(localHandle != null);
            }
        }
Exemplo n.º 21
0
 public static extern bool CryptCreateHash(SafeCspHandle hProv,
                                           AlgorithmId Algid,
                                           SafeCapiKeyHandle hKey,
                                           int dwFlags,
                                           [Out] out SafeCapiHashHandle phHash);
Exemplo n.º 22
0
 public static extern bool CryptGenKey(SafeCspHandle hProv, CapiNative.AlgorithmId Algid, CapiNative.KeyFlags dwFlags, out SafeCapiKeyHandle phKey);
Exemplo n.º 23
0
 internal static void SetKeyParameter(SafeCapiKeyHandle key, KeyParameter parameter, int value)
 {
     SetKeyParameter(key, parameter, BitConverter.GetBytes(value));
 }
Exemplo n.º 24
0
 public static extern bool CryptDuplicateKey(SafeCapiKeyHandle hKey,
                                             IntPtr pdwReserved,
                                             int dwFlags,
                                             [Out] out SafeCapiKeyHandle phKey);
 private ICryptoTransform CreateDecryptor(SafeCapiKeyHandle key, byte[] iv)
 {
     return(new CapiSymmetricAlgorithm(base.BlockSizeValue, base.FeedbackSizeValue, this.m_cspHandle, key, iv, this.Mode, base.PaddingValue, EncryptionMode.Decrypt));
 }
Exemplo n.º 26
0
 public static extern bool CryptExportKey(SafeCapiKeyHandle hKey,
                                          SafeCapiKeyHandle hExpKey,
                                          int dwBlobType,            // (int)KeyBlobType
                                          int dwExportFlags,
                                          [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
                                          [In, Out] ref int pdwDataLen);
Exemplo n.º 27
0
        internal static SafeCapiKeyHandle ImportSymmetricKey(SafeCspHandle provider, AlgorithmId algorithm, byte[] key)
        {
            Contract.Requires(provider != null);
            Contract.Requires(((int)algorithm & (int)AlgorithmClass.DataEncryption) == (int)AlgorithmClass.DataEncryption);
            Contract.Requires(key != null);
            Contract.Ensures(Contract.Result <SafeCapiKeyHandle>() != null &&
                             !Contract.Result <SafeCapiKeyHandle>().IsInvalid&&
                             !Contract.Result <SafeCapiKeyHandle>().IsClosed);

            //
            // Setup a PLAINTEXTKEYBLOB (v2) which has the following format:
            //   BLOBHEADER hdr
            //   DWORD      cbKeySize
            //   BYTE       rbgKeyData[]
            //

            int blobSize = Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)) + key.Length;

            byte[] keyBlob = new byte[blobSize];

            unsafe
            {
                fixed(byte *pBlob = keyBlob)
                {
                    BLOBHEADER *pHeader = (BLOBHEADER *)pBlob;

                    pHeader->bType    = KeyBlobType.PlainText;
                    pHeader->bVersion = 2;
                    pHeader->reserved = 0;
                    pHeader->aiKeyAlg = algorithm;

                    int *pSize = (int *)(pBlob + Marshal.SizeOf(*pHeader));

                    *pSize = key.Length;
                }
            }

            Buffer.BlockCopy(key, 0, keyBlob, Marshal.SizeOf(typeof(BLOBHEADER)) + Marshal.SizeOf(typeof(int)), key.Length);

            // Import the PLAINTEXTKEYBLOB into the CSP
            SafeCapiKeyHandle importedKey = null;

            RuntimeHelpers.PrepareConstrainedRegions();
            try {
                if (!UnsafeNativeMethods.CryptImportKey(provider,
                                                        keyBlob,
                                                        keyBlob.Length,
                                                        SafeCapiKeyHandle.InvalidHandle,
                                                        KeyFlags.Exportable,
                                                        out importedKey))
                {
                    throw new CryptographicException(Marshal.GetLastWin32Error());
                }
            }
            finally {
                if (importedKey != null && !importedKey.IsInvalid)
                {
                    importedKey.SetParentCsp(provider);
                }
            }
            return(importedKey);
        }
Exemplo n.º 28
0
 public static extern bool CryptGenKey(SafeCspHandle hProv,
                                       AlgorithmId Algid,
                                       KeyFlags dwFlags,
                                       [Out] out SafeCapiKeyHandle phKey);
Exemplo n.º 29
0
 public static extern bool CryptSetKeyParam(SafeCapiKeyHandle hKey,
                                            KeyParameter dwParam,
                                            [MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
                                            int dwFlags);
Exemplo n.º 30
0
 public static extern bool CryptImportKey(SafeCspHandle hProv,
                                          [MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
                                          int dwDataLen,
                                          SafeCapiKeyHandle hPubKey,
                                          KeyFlags dwFlags,
                                          [Out] out SafeCapiKeyHandle phKey);