Example #1
0
        public static Secret HybridEncrypt
        (
            RSACryptoServiceProvider encryptorPrivateKeyPfxProvider
            , X509Certificate2 encryptorPublicKeyCer
            , RSACryptoServiceProvider decryptorPublicKeyCerProvider
            , HashSignatureMode signHashMode
            , bool DoOAEPadding
            , byte[] data
        )
        {
            Secret secret = new Secret();

            using (TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider())
            {
                provider.GenerateIV();
                secret.EncryptorSharedEncryptedOnceIV = provider.IV;
                provider.GenerateKey();
                secret.EncryptorSharedEncryptedOnceKey = provider.Key;
                secret.EncryptedData = provider.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
            }
            secret.EncryptorSharedEncryptedOnceIV  = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceIV, DoOAEPadding);
            secret.EncryptorSharedEncryptedOnceKey = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceKey, DoOAEPadding);
            HashAlgorithm hashAlgorithm;

            if (signHashMode == HashSignatureMode.SHA1)
            {
                hashAlgorithm = new SHA1CryptoServiceProvider();
            }
            else //(hashSignatureMode == HashSignatureMode.MD5)
            {
                hashAlgorithm = new MD5CryptoServiceProvider();
            }
            MemoryStream stream = new MemoryStream();

            byte[] buffer = secret.EncryptorSharedEncryptedOnceIV;
            stream.Write(buffer, 0, buffer.Length);
            buffer = secret.EncryptorSharedEncryptedOnceKey;
            stream.Write(buffer, 0, buffer.Length);
            buffer          = secret.EncryptedData;
            stream.Position = 0;
            buffer          = hashAlgorithm.ComputeHash(stream);
            stream.Close();
            stream.Dispose();
            secret.EncryptorHashSignature
                = encryptorPrivateKeyPfxProvider
                  .SignHash
                  (
                      buffer
                      , Enum.GetName
                      (
                          signHashMode.GetType()
                          , signHashMode
                      )
                  );
            secret.EncryptorPublicKeyCerRawData = encryptorPublicKeyCer.RawData;
            secret.SignHashMode = signHashMode;
            secret.DoOAEPadding = DoOAEPadding;
            return(secret);
        }
Example #2
0
        public static Secret HybridEncrypt
        (
            string encryptorPrivateKeyPfxFileName
            , string encryptorPublicKeyCerFileName
            , string decryptorPublicKeyCerFileName
            , HashSignatureMode hashSignatureMode
            , bool DoOAEPadding
            , byte[] data
        )
        {
            X509Certificate2 encryptorPrivateKeyPfx = null;
            X509Certificate2 encryptorPublicKeyCer  = null;
            X509Certificate2 decryptorPublicKeyCer  = null;

            try
            {
                encryptorPrivateKeyPfx = new X509Certificate2(encryptorPrivateKeyPfxFileName);
                encryptorPublicKeyCer  = new X509Certificate2(encryptorPublicKeyCerFileName);
                decryptorPublicKeyCer  = new X509Certificate2(decryptorPublicKeyCerFileName);
                return(HybridEncrypt
                       (
                           encryptorPrivateKeyPfx
                           , encryptorPublicKeyCer
                           , decryptorPublicKeyCer
                           , hashSignatureMode
                           , DoOAEPadding
                           , data
                       ));
            }
            catch
            {
                return(null);
            }
            finally
            {
                if (encryptorPrivateKeyPfx != null)
                {
                    encryptorPrivateKeyPfx.Reset();
                }
                if (encryptorPublicKeyCer != null)
                {
                    encryptorPublicKeyCer.Reset();
                }
                if (decryptorPublicKeyCer != null)
                {
                    decryptorPublicKeyCer.Reset();
                }
            }
        }
Example #3
0
        public static Secret HybridEncrypt
        (
            byte[] encryptorPrivateKeyPfxRawData
            , byte[] encryptorPublicKeyCerRawData
            , byte[] decryptorPublicKeyCerRawData
            , HashSignatureMode hashSignatureMode
            , bool DoOAEPadding
            , byte[] data
        )
        {
            X509Certificate2 encryptorPrivateKeyPfx = null;
            X509Certificate2 encryptorPublicKeyCer  = null;
            X509Certificate2 decryptorPublicKeyCer  = null;

            try
            {
                encryptorPrivateKeyPfx = null;
                encryptorPublicKeyCer  = null;
                decryptorPublicKeyCer  = null;
                return(HybridEncrypt
                       (
                           encryptorPrivateKeyPfx
                           , encryptorPublicKeyCer
                           , decryptorPublicKeyCer
                           , hashSignatureMode
                           , DoOAEPadding
                           , data
                       ));
            }
            catch
            {
                return(null);
            }
            finally
            {
                if (encryptorPrivateKeyPfx != null)
                {
                    encryptorPrivateKeyPfx.Reset();
                }
                if (encryptorPublicKeyCer != null)
                {
                    encryptorPublicKeyCer.Reset();
                }
                if (decryptorPublicKeyCer != null)
                {
                    decryptorPublicKeyCer.Reset();
                }
            }
        }
Example #4
0
        public static Secret HybridEncrypt
        (
            X509Certificate2 encryptorPrivateKeyPfx
            , X509Certificate2 encryptorPublicKeyCer
            , X509Certificate2 decryptorPublicKeyCer
            , HashSignatureMode signHashMode
            , bool DoOAEPadding
            , byte[] data
        )
        {
            RSACryptoServiceProvider encryptorPrivateKeyPfxProvider = encryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
            RSACryptoServiceProvider decryptorPublicKeyCerProvider  = decryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;

            return(HybridEncrypt
                   (
                       encryptorPrivateKeyPfxProvider
                       , encryptorPublicKeyCer
                       , decryptorPublicKeyCerProvider
                       , signHashMode
                       , DoOAEPadding
                       , data
                   ));
        }
 public static Secret HybridEncrypt
                             (
                                 RSACryptoServiceProvider encryptorPrivateKeyPfxProvider
                                 , X509Certificate2 encryptorPublicKeyCer
                                 , RSACryptoServiceProvider decryptorPublicKeyCerProvider
                                 , HashSignatureMode signHashMode
                                 , bool DoOAEPadding
                                 , byte[] data
                             )
 {
     Secret secret = new Secret();
     using (TripleDESCryptoServiceProvider provider = new TripleDESCryptoServiceProvider())
     {
         provider.GenerateIV();
         secret.EncryptorSharedEncryptedOnceIV = provider.IV;
         provider.GenerateKey();
         secret.EncryptorSharedEncryptedOnceKey = provider.Key;
         secret.EncryptedData = provider.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
     }
     secret.EncryptorSharedEncryptedOnceIV = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceIV, DoOAEPadding);
     secret.EncryptorSharedEncryptedOnceKey = decryptorPublicKeyCerProvider.Encrypt(secret.EncryptorSharedEncryptedOnceKey, DoOAEPadding);
     HashAlgorithm hashAlgorithm;
     if (signHashMode == HashSignatureMode.SHA1)
     {
         hashAlgorithm = new SHA1CryptoServiceProvider();
     }
     else //(hashSignatureMode == HashSignatureMode.MD5)
     {
         hashAlgorithm = new MD5CryptoServiceProvider();
     }
     MemoryStream stream = new MemoryStream();
     byte[] buffer = secret.EncryptorSharedEncryptedOnceIV;
     stream.Write(buffer, 0, buffer.Length);
     buffer = secret.EncryptorSharedEncryptedOnceKey;
     stream.Write(buffer, 0, buffer.Length);
     buffer = secret.EncryptedData;
     stream.Position = 0;
     buffer = hashAlgorithm.ComputeHash(stream);
     stream.Close();
     stream.Dispose();
     secret.EncryptorHashSignature = encryptorPrivateKeyPfxProvider.SignHash
                                                                         (
                                                                             buffer
                                                                             , Enum.GetName
                                                                                         (
                                                                                             signHashMode.GetType()
                                                                                             , signHashMode
                                                                                         )
                                                                         );
     secret.EncryptorPublicKeyCerRawData = encryptorPublicKeyCer.RawData;
     secret.SignHashMode = signHashMode;
     secret.DoOAEPadding = DoOAEPadding;
     return secret;
 }
 public static Secret HybridEncrypt
                             (
                                 X509Certificate2 encryptorPrivateKeyPfx
                                 , X509Certificate2 encryptorPublicKeyCer
                                 , X509Certificate2 decryptorPublicKeyCer
                                 , HashSignatureMode signHashMode
                                 , bool DoOAEPadding
                                 , byte[] data
                             )
 {
     RSACryptoServiceProvider encryptorPrivateKeyPfxProvider = encryptorPrivateKeyPfx.PrivateKey as RSACryptoServiceProvider;
     RSACryptoServiceProvider decryptorPublicKeyCerProvider = decryptorPublicKeyCer.PublicKey.Key as RSACryptoServiceProvider;
     return HybridEncrypt
                 (
                     encryptorPrivateKeyPfxProvider
                     , encryptorPublicKeyCer
                     , decryptorPublicKeyCerProvider
                     , signHashMode
                     , DoOAEPadding
                     , data
                 );
 }
 public static Secret HybridEncrypt
                             (
                                 string encryptorPrivateKeyPfxFileName
                                 , string encryptorPublicKeyCerFileName
                                 , string decryptorPublicKeyCerFileName
                                 , HashSignatureMode hashSignatureMode
                                 , bool DoOAEPadding
                                 , byte[] data
                             )
 {
     X509Certificate2 encryptorPrivateKeyPfx = null;
     X509Certificate2 encryptorPublicKeyCer = null;
     X509Certificate2 decryptorPublicKeyCer = null;
     try
     {
         encryptorPrivateKeyPfx = new X509Certificate2(encryptorPrivateKeyPfxFileName);
         encryptorPublicKeyCer = new X509Certificate2(encryptorPublicKeyCerFileName);
         decryptorPublicKeyCer = new X509Certificate2(decryptorPublicKeyCerFileName);
         return HybridEncrypt
                 (
                     encryptorPrivateKeyPfx
                     , encryptorPublicKeyCer
                     , decryptorPublicKeyCer
                     , hashSignatureMode
                     , DoOAEPadding
                     , data
                 );
     }
     catch
     {
         return null;
     }
     finally
     {
         if (encryptorPrivateKeyPfx != null)
         {
             encryptorPrivateKeyPfx.Reset();
         }
         if (encryptorPublicKeyCer != null)
         {
             encryptorPublicKeyCer.Reset();
         }
         if (decryptorPublicKeyCer != null)
         {
             decryptorPublicKeyCer.Reset();
         }
     }
 }
 public static Secret HybridEncrypt
                             (
                                 byte[] encryptorPrivateKeyPfxRawData
                                 , byte[] encryptorPublicKeyCerRawData
                                 , byte[] decryptorPublicKeyCerRawData
                                 , HashSignatureMode hashSignatureMode
                                 , bool DoOAEPadding
                                 , byte[] data
                             )
 {
     X509Certificate2 encryptorPrivateKeyPfx = null;
     X509Certificate2 encryptorPublicKeyCer = null;
     X509Certificate2 decryptorPublicKeyCer = null;
     try
     {
         encryptorPrivateKeyPfx = null;
         encryptorPublicKeyCer = null;
         decryptorPublicKeyCer = null;
         return HybridEncrypt
                 (
                     encryptorPrivateKeyPfx
                     , encryptorPublicKeyCer
                     , decryptorPublicKeyCer
                     , hashSignatureMode
                     , DoOAEPadding
                     , data
                 );
     }
     catch
     {
         return null;
     }
     finally
     {
         if (encryptorPrivateKeyPfx != null)
         {
             encryptorPrivateKeyPfx.Reset();
         }
         if (encryptorPublicKeyCer != null)
         {
             encryptorPublicKeyCer.Reset();
         }
         if (decryptorPublicKeyCer != null)
         {
             decryptorPublicKeyCer.Reset();
         }
     }
 }