CreateDecryptor() public method

public CreateDecryptor ( ) : ICryptoTransform
return ICryptoTransform
Esempio n. 1
0
        static Dictionary<string, string> Decrypt(string cipherText, string encryptionPassword, string salt)
        {
            using (var algorithm = new AesCryptoServiceProvider
            {
                Key =GetEncryptionKey(encryptionPassword),
                IV = Convert.FromBase64String(salt)
            })
            using (var decryptor = algorithm.CreateDecryptor())
            using (var decryptedTextStream = new MemoryStream())
            using (var stringReader = new StreamReader(decryptedTextStream, Encoding.UTF8))
            using (var jsonReader = new JsonTextReader(stringReader))
            {
                try
                {
                    using (var cryptoStream = new CryptoStream(decryptedTextStream, decryptor, CryptoStreamMode.Write))
                    {
                        var cipherTextBytes = Convert.FromBase64String(cipherText);
                        cryptoStream.Write(cipherTextBytes, 0, cipherTextBytes.Length);
                        cryptoStream.FlushFinalBlock();

                        var dictionary = new Dictionary<string, string>();
                        var serializer = new JsonSerializer();
                        decryptedTextStream.Position = 0;
                        serializer.Populate(jsonReader, dictionary);
                        return dictionary;
                    }
                }
                catch (CryptographicException cryptoException)
                {
                    throw new CommandException(
                        "Cannot decrypt sensitive-variables. Check your password is correct.\nError message: " +
                        cryptoException.Message);
                }
            }
        }
Esempio n. 2
0
        /// <summary>
        /// Decrypts data from one stream to another stream.
        /// </summary>
        /// <param name="input">Stream containing encrypted data</param>
        /// <param name="output">Stream that will receive the decrypted data</param>
        /// <param name="encryptionKey">Key to decrypt the data with</param>
        /// <param name="IV">IV to decrypt the data with</param>
        internal static void DecryptAesStream(Stream input, Stream output, byte[] encryptionKey, byte[] IV)
        {
            using (var aes = new AesCryptoServiceProvider {Padding = PaddingMode.ISO10126})
            using (var decryptor = aes.CreateDecryptor(encryptionKey, IV))
            {
                var lengthBytes = new byte[AesHeaderSize];
                input.Read(lengthBytes, 0, AesHeaderSize);
                var length = BitConverter.ToInt32(lengthBytes, 0);

                using (var cs = new CryptoStream(input, decryptor, CryptoStreamMode.Read))
                {
                    long position = BufferSize;
                    var buffer = new byte[BufferSize];

                    while (position<length)
                    {
                        cs.Read(buffer, 0, BufferSize);
                        output.Write(buffer, 0, BufferSize);

                        position += BufferSize;
                    }

                    int offset = length % BufferSize;
                    if (offset>0)
                    {
                        cs.Read(buffer, 0, offset);
                        output.Write(buffer, 0, offset);
                    }
                    output.Flush();
                }
            }
        }
Esempio n. 3
0
        /// <summary>
        /// Decrypts the specified crypt text.
        /// </summary>
        /// <param name="cryptoText">The crypto text.</param>
        /// <returns>The plain text.</returns>
        public string Decrypt(byte[] cryptoText)
        {
            string clearText;

            using (var aes = new AesCryptoServiceProvider())
            {
                aes.Key = this.Key;
                aes.IV = this.InitalizationVector;

                var decryptor = aes.CreateDecryptor(aes.Key, aes.IV);

                using (var memoryStream = new MemoryStream(cryptoText))
                {
                    using (var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read))
                    {
                        using (var streamReader = new StreamReader(cryptoStream))
                        {
                            clearText = streamReader.ReadToEnd();
                        }
                    }
                }
            }

            return clearText;
        }
Esempio n. 4
0
        public static string Decrypt(string input)
        {
            //byte[] inputBytes = Convert.FromBase64String(input); //Encoding.UTF8.GetBytes(input);
            string[] sInput = input.Split("-".ToCharArray());
            byte[] inputBytes = new byte[sInput.Length];
            for (int i = 0; i < sInput.Length; i++)
            {
                inputBytes[i] = byte.Parse(sInput[i], NumberStyles.HexNumber);
            }
            byte[] keyBytes = Encoding.UTF8.GetBytes(key.Substring(0, 32));
            using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
            {
                aesAlg.Key = keyBytes;
                aesAlg.IV = AesIv;

                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                using (MemoryStream msEncrypt = new MemoryStream(inputBytes))
                {
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srEncrypt = new StreamReader(csEncrypt))
                        {
                            return srEncrypt.ReadToEnd();
                        }
                    }
                }
            }
        }
Esempio n. 5
0
 public void SetUp()
 {
     using ( AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider() ) {
         m_Encryptor = aesAlg.CreateEncryptor();
         m_Decryptor = aesAlg.CreateDecryptor();
     }
 }
Esempio n. 6
0
        public void Decrypt(string filename)
        {
            FileStream fsInput = new FileStream(filename, FileMode.Open, FileAccess.Read);
            FileStream fsOutput = new FileStream(filename + ".crypt", FileMode.Create, FileAccess.Write);
            AesCryptoServiceProvider Aes = new AesCryptoServiceProvider();

            Aes.KeySize = 128;

            byte[] input = new byte[256];

            int count = fsInput.Read(input, 0, 256);
            Aes.Key = _algorithm_asym.Decrypt(input, false);
            count = fsInput.Read(input, 0, 256);
            Aes.IV = _algorithm_asym.Decrypt(input, false);

            ICryptoTransform desencrypt = Aes.CreateDecryptor();
            CryptoStream cryptostream = new CryptoStream(fsOutput, desencrypt, CryptoStreamMode.Write);

            byte[] bytearrayinput = new byte[fsInput.Length - 1];
            fsInput.Read(bytearrayinput, 0, bytearrayinput.Length);
            cryptostream.Write(bytearrayinput, 0, bytearrayinput.Length);

            fsInput.Close();
            fsOutput.Close();
        }
        public string Decription(byte[] encryptedData, byte[] alicePubKeyBlob)
        {
            byte[] rawData = null;

            var aes = new AesCryptoServiceProvider();

            int nBytes = aes.BlockSize >> 3;
            byte[] iv = new byte[nBytes];
            for (int i = 0; i < iv.Length; i++)
                iv[i] = encryptedData[i];

            using (var bobAlgorithm = new ECDiffieHellmanCng(privKey))
            using (CngKey alicePubKey = CngKey.Import(alicePubKeyBlob,
                  CngKeyBlobFormat.EccPublicBlob))
            {
                byte[] symmKey = bobAlgorithm.DeriveKeyMaterial(alicePubKey);
                aes.Key = symmKey;
                aes.IV = iv;

                using (ICryptoTransform decryptor = aes.CreateDecryptor())
                using (MemoryStream ms = new MemoryStream())
                {
                    var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
                    cs.Write(encryptedData, nBytes, encryptedData.Length - nBytes);
                    cs.Close();

                    rawData = ms.ToArray();
                }
                aes.Clear();
            }
            return Encoding.UTF8.GetString(rawData);
        }
Esempio n. 8
0
        public static byte[] Decrypt(byte[] encryptedString, string privateKey)
        {
            //  We hash the private key string to ensure we have a key with the correct
            //  number of bytes.
            var privateKeyHash = HashKey(privateKey);

            using (var provider = new AesCryptoServiceProvider())
            {
                provider.Key = privateKeyHash;
                using (var ms = new MemoryStream(encryptedString))
                {
                    // Read the first 16 bytes which is the IV.
                    byte[] iv = new byte[16];
                    ms.Read(iv, 0, 16);
                    provider.IV = iv;

                    using (var decryptor = provider.CreateDecryptor())
                    {
                        using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                        {
                            return ReadToEnd(cs);
                        }
                    }
                }
            }
        }
Esempio n. 9
0
File: Aes.cs Progetto: jamezoon/XF
        /// <summary>
        /// 解密字节数组
        /// </summary>
        /// <param name="inputData">要解密的字节数据</param>
        /// <param name="password">密码</param>
        /// <returns></returns>
        public static byte[] Decrypt(byte[] inputData, string password)
        {
            AesCryptoServiceProvider aes = new AesCryptoServiceProvider
            {
                Key = GetKeyArray(password),
                Mode = cipherMode,
                Padding = paddingMode
            };

            var transform = aes.CreateDecryptor();

            byte[] data = null;

            try
            {
                data = transform.TransformFinalBlock(inputData, 0, inputData.Length);
            }
            catch
            {
                return null;
            }

            aes.Clear();

            return data;
        }
Esempio n. 10
0
        public static long Decrypt(string cipherText)
        {
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");
            if (AesCryptoServiceProvider.Key == null || AesCryptoServiceProvider.Key.Length <= 0)
                throw new ArgumentNullException("Key");
            if (AesCryptoServiceProvider.IV == null || AesCryptoServiceProvider.IV.Length <= 0)
                throw new ArgumentNullException("IV");

            string plaintext;

            using (var aesAlg = new AesCryptoServiceProvider())
            {
                aesAlg.Key = AesCryptoServiceProvider.Key;
                aesAlg.IV = AesCryptoServiceProvider.IV;

                var decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                using (var msDecrypt = new MemoryStream(Convert.FromBase64String(cipherText)))
                {
                    using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (var srDecrypt = new StreamReader(csDecrypt))
                        {
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return Convert.ToInt64(plaintext);
        }
Esempio n. 11
0
 protected override string DecryptByBlocks(byte[] key, byte[] iv,
     List<byte> cipherText)
 {
     var message = new StringBuilder();
     using (var aes = new AesCryptoServiceProvider())
     {
         aes.BlockSize = BlockSize * 8;
         aes.KeySize = KeySize * 8;
         aes.Key = key;
         aes.IV = iv;
         aes.Padding = PaddingMode.None;
         using (var decr = aes.CreateDecryptor())
         {
             while (cipherText.Count != 0)
             {
                 if (cipherText.Count == BlockSize)
                 {
                     aes.Padding = PaddingMode.PKCS7;
                 }
                 var block = DetachBlock(cipherText);
                 var decrypted = new byte[BlockSize];
                 decr.TransformBlock(block, 0, BlockSize, decrypted, 0);
                 if (!decrypted.All(x => x == BlockSize))
                 {
                     message.Append(BytesToPlainText(decrypted));
                 }
                 aes.IV = block;
             }
         }
     }
     return message.ToString();
 }
Esempio n. 12
0
        public string decrypt(byte[] msg, byte[] key)
        {
            using (var d = new System.Security.Cryptography.AesCryptoServiceProvider())
            {
                var iv = Enumerable.Repeat((byte)0, 16).ToArray();
                d.IV      = iv;
                d.Key     = key;
                d.Mode    = CipherMode.CBC;
                d.Padding = PaddingMode.None;

                var t = d.CreateDecryptor();

                using (var ms = new System.IO.MemoryStream(msg))
                {
                    using (var cs = new CryptoStream(ms, t, CryptoStreamMode.Read))
                    {
                        using (var sr = new System.IO.StreamReader(cs))
                        {
                            var r = sr.ReadToEnd();
                            return(r);
                        }
                    }
                }
            }
        }
Esempio n. 13
0
        public string Decrypt(string cipherText, string key, string iv)
        {
             try
            {
                AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
                //aes.BlockSize = 128; //aes.KeySize = 256;
                aes.Mode = CipherMode.CBC;
                aes.Padding = PaddingMode.PKCS7;
                aes.IV = new byte[16];// Encoding.UTF8.GetBytes("DBDF15AA65379176");
                aes.Key = Encoding.UTF8.GetBytes(key);

                // Convert Base64 strings to byte array
                byte[] src = System.Convert.FromBase64String(cipherText);

                // decryption
                using (ICryptoTransform decrypt = aes.CreateDecryptor())
                {
                    byte[] dest = decrypt.TransformFinalBlock(src, 0, src.Length);
                    return Encoding.UTF8.GetString(dest);
                }
            }
            catch
            {
                return string.Empty;
            }
        }
        /// <summary>
        /// Decrypts a file encrypted with AES
        /// </summary>
        /// <param name="filePath">Full path of the file to be decrypted</param>
        /// <param name="outputFilePath">Full path of the decrypted file</param>
        /// <param name="key">AES decryption key</param>
        /// <param name="iv">AES initialization vector</param>
        /// <param name="useECBMode">boolean to determine if ECB or CBC mode is used</param>
        public static void DecryptFile(string filePath, string outputFilePath, byte[] key, byte[] iv, bool useECBMode)
        {
            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider())
            {
                if (useECBMode)
                    aes.Mode = CipherMode.ECB;
                else
                    aes.Mode = CipherMode.CBC;

                aes.Key = key;
                aes.IV = iv;

                using (ICryptoTransform cryptoTransform = aes.CreateDecryptor(aes.Key, aes.IV))
                {
                    using (FileStream encrypted = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read))
                    {
                        using (FileStream plain = File.Open(outputFilePath, FileMode.Create, FileAccess.Write, FileShare.None))
                        {
                            using (CryptoStream cs = new CryptoStream(plain, cryptoTransform, CryptoStreamMode.Write))
                            {
                                encrypted.CopyTo(cs, bufferSize);
                            }
                        }
                    }
                }
            }
        }
Esempio n. 15
0
        /// <summary>
        /// Decrypt a message using AES in CBC (cipher-block chaining) mode.
        /// </summary>
        /// <param name="ciphertext">The message encrypted with AES in CBC mode</param>
        /// <param name="key">The key used to encrypt the message</param>
        /// <param name="iv">The initialization vector provided, if one was provided.  If you are absolutely certain
        /// the key will only be used once, an IV is not necessary and zero will be used.</param>
        /// <param name="checkAndRemoveHmac">Set if an HMACHSA256 was placed at the end of the plaintext before encrypting.
        /// The HMAC will be removed before the plaintext is returned.  If the HMAC does not match, the method will throw a
        /// System.Security.Cryptography.CryptographicException.</param>
        /// <returns>The plaintext resulting from decrypting the ciphertext with the given key.</returns>
        public static byte[] DecryptAesCbc(byte[] ciphertext, byte[] key, byte[] iv = null, bool checkAndRemoveHmac = false)
        {
            using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider())
            {
                aes.Key = key;
                if (iv == null)
                    iv = NullIv;

                aes.IV = iv;
                aes.Mode = CipherMode.CBC;

                // Decrypt the message 
                using (System.IO.MemoryStream plaintextStream = new System.IO.MemoryStream())
                {
                    using (CryptoStream cs = new CryptoStream(plaintextStream, aes.CreateDecryptor(), CryptoStreamMode.Write))
                    {
                        cs.Write(ciphertext, 0, ciphertext.Length);
                    }
                    byte[] plaintext = plaintextStream.ToArray();
                    if (checkAndRemoveHmac)
                    {
                        byte[] hmacProvided = plaintext.Skip(plaintext.Length - Sha256HmacLength).ToArray();
                        plaintext = plaintext.Take(plaintext.Length - Sha256HmacLength).ToArray();
                        byte[] hmacCalculated = new HMACSHA256(key).ComputeHash(plaintext);
                        if (!hmacProvided.SequenceEqual(hmacCalculated))
                            throw new CryptographicException("Message authentication code validation failed.");
                    }
                    return plaintext;
                }
            }
        }
Esempio n. 16
0
 public static string AESDecryptor(string encryptedString, byte[] Key, byte[] IV)
 {
     byte[] data = Convert.FromBase64String(encryptedString);
     AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
     string decryptedString = ASCIIEncoding.ASCII.GetString(aes.CreateDecryptor(Key, IV).TransformFinalBlock(data, 0, data.Length));
     return decryptedString;
 }
Esempio n. 17
0
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="str">待解密字符串</param>
        /// <returns>解密后字符串</returns>
        public static string AesDecrypt(string str)
        {
            try
            {

                string key = AES_KEY;
                byte[] cipherText = Convert.FromBase64String(str);
                AesCryptoServiceProvider aes = new AesCryptoServiceProvider();
                aes.Key = Encoding.UTF8.GetBytes(key);
                //aes.IV = Encoding.UTF8.GetBytes(key);
                aes.Mode = CipherMode.ECB;
                aes.Padding = PaddingMode.PKCS7;
                byte[] decryptBytes = new byte[cipherText.Length];
                using (MemoryStream ms = new MemoryStream(cipherText))
                {
                    using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Read))
                    {
                        cs.Read(decryptBytes, 0, decryptBytes.Length);
                        cs.Close();
                        ms.Close();
                    }
                }
                return Encoding.UTF8.GetString(decryptBytes).Replace("\0", "");   //将字符串后尾的'\0'去掉
            }
            catch { }
            return str;
        }
Esempio n. 18
0
 public byte[] Unprotect(byte[] protectedData)
 {
     byte[] output = null;
     using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
     {
         aesAlg.Key = _key;
         aesAlg.IV = _IV;
         ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
         using (MemoryStream msDecrypt = new MemoryStream(protectedData))
         {
             using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
             {
                 byte[] buffer = new byte[8];
                 using (MemoryStream msOutput = new MemoryStream())
                 {
                     int read;
                     while ((read = csDecrypt.Read(buffer, 0, buffer.Length)) > 0)
                     {
                         msOutput.Write(buffer, 0, read);
                     }
                     output = msOutput.ToArray();
                 }
             }
         }
     }
     return output;
 }
        private Stream DecryptMessage(Stream outputStream, string keyString)
        {
            var key = Convert.FromBase64String(keyString);
            using (var provider = new AesCryptoServiceProvider())
            {
                provider.Key = key;
                provider.Mode = CipherMode.CBC;
                provider.Padding = PaddingMode.PKCS7;

                var ms = new MemoryStream();
                outputStream.CopyTo(ms);

                ms.Seek(0, SeekOrigin.Begin);
                ms.Position = 0;
                byte[] iv = new byte[16];
                ms.Read(iv, 0, 16);

                provider.IV = iv;
                Trace.WriteLine("IV decrypt " + provider.IV);
                var decryptor = provider.CreateDecryptor(provider.Key, provider.IV);

                return new CryptoStream(ms, decryptor, CryptoStreamMode.Read);

            }
        }
Esempio n. 20
0
        /// <summary>
        /// AES解密
        /// </summary>
        /// <param name="inputString">密钥</param>
        /// <param name="sKey">向量</param>
        /// <returns>明文</returns>
        public static string DecryptAES(string inputString, string sKey = Key)
        {
            if (string.IsNullOrWhiteSpace(inputString))
                return string.Empty;

            string plaintext = null;
            using (AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider())
            {
                aesAlg.KeySize = 128;
                aesAlg.Key = ASCIIEncoding.ASCII.GetBytes(sKey);
                aesAlg.IV = ASCIIEncoding.ASCII.GetBytes(sKey);

                ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);

                using (MemoryStream msDecrypt = new MemoryStream(Convert.FromBase64String(inputString)))
                {
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                        {
                            plaintext = srDecrypt.ReadToEnd();
                        }
                    }
                }
            }

            return plaintext;
        }
Esempio n. 21
0
        private static void BobReceiveData(byte[] encryptData)
        {
            byte[] rawdata = null;
            var aes = new AesCryptoServiceProvider();
            int nBytes = aes.BlockSize >> 3; // bit to Byte, need to devide 8
            byte[] iv = new byte[nBytes];

            for (int i = 0; i < iv.Length; i++)
                iv[i] = encryptData[i];
            using (var bobAlgorithm = new ECDiffieHellmanCng(bobKey))
            using (CngKey alicePubKey = CngKey.Import(alicePubKeyBlob, CngKeyBlobFormat.EccPublicBlob))
            {
                byte[] symmKey = bobAlgorithm.DeriveKeyMaterial(alicePubKey);
                Console.WriteLine(Convert.ToBase64String(symmKey));
                aes.Key = symmKey;
                aes.IV = iv;
            }
            using (ICryptoTransform decryptor = aes.CreateDecryptor())
            using (MemoryStream ms = new MemoryStream())
            {
                var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write);
                cs.Write(encryptData, nBytes, encryptData.Length - nBytes);
                cs.Close();
                rawdata = ms.ToArray();
                Console.WriteLine(Encoding.UTF8.GetString(rawdata));
            }
            aes.Clear();
        }
        public static string DecryptString(byte[] encryptedString, byte[] encryptionKey)
        {
            using (var provider = new AesCryptoServiceProvider())
            {
                provider.Key = encryptionKey;
                using (var ms = new MemoryStream(encryptedString))
                {
                    // Read the first 16 bytes which is the IV.
                    byte[] iv = new byte[16];
                    ms.Read(iv, 0, 16);
                    provider.IV = iv;

                    using (var decryptor = provider.CreateDecryptor())
                    {
                        using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
                        {
                            using (var sr = new StreamReader(cs))
                            {
                                return sr.ReadToEnd();
                            }
                        }
                    }
                }
            }
        }
Esempio n. 23
0
        void Button2Click(object sender, EventArgs e)
        {
            if (openfile.ShowDialog() == DialogResult.OK)
            {
                    FileStream fsFileIn = File.OpenRead(textBox2.Text);

                    FileStream fsKeyFile = File.OpenRead(openfile.FileName);

                    FileStream fsFileOut = File.Create(textBox2.Text+"_decrypt");

                    AesCryptoServiceProvider cryptAlgorithm = new AesCryptoServiceProvider();
                    BinaryReader brFile = new BinaryReader(fsKeyFile);
                    //textBox1.Text = key.ToString();
                    StreamWriter writer = File.AppendText(@"key.txt");
                    writer.WriteLine(key.Length);
                    cryptAlgorithm.Key = key;
                    cryptAlgorithm.IV = iv;

                    CryptoStream csEncrypt = new CryptoStream(fsFileIn, cryptAlgorithm.CreateDecryptor(), CryptoStreamMode.Read);

                    StreamReader srStream = new StreamReader(csEncrypt);
                    StreamWriter swStream = new StreamWriter(fsFileOut);

                    swStream.WriteLine(srStream.ReadToEnd());

                    swStream.Close();
                    fsFileOut.Close();
                    srStream.Close();

            }
        }
Esempio n. 24
0
        // ReSharper disable once InconsistentNaming
        public byte[] DecryptAES(byte[] dataToDecrypt, byte[] key, byte[] iv)
        {
            using (var aes = new AesCryptoServiceProvider())
            {
                _logger.Info("mode: CBC");
                aes.Mode = CipherMode.CBC;
                _logger.Info("padding: PKCS7");
                aes.Padding = PaddingMode.PKCS7;

                aes.Key = key;
                aes.IV = iv;

                _logger.Info("create stream");
                using (var memoryStream = new MemoryStream())
                {
                    var cryptoStream = new CryptoStream(memoryStream,
                        aes.CreateDecryptor(), CryptoStreamMode.Write);

                    _logger.Info("write data to stream");
                    cryptoStream.Write(dataToDecrypt, 0, dataToDecrypt.Length);
                    cryptoStream.FlushFinalBlock();

                    byte[] decryptBytes = memoryStream.ToArray();

                    return decryptBytes;
                }
            }
        }
Esempio n. 25
0
        public string PerformDecryption(string input)
        {
            string output = "";
            Aes aes = new AesCryptoServiceProvider();
            //DES des = new DESCryptoServiceProvider();
            aes.Mode = CipherMode.CBC;
            try
            {
                UTF8Encoding utf8 = new UTF8Encoding();
                byte[] ciphertext = Convert.FromBase64String(input);
                byte[] key = Encoding.ASCII.GetBytes(Security_Key);
                byte[] IV = Encoding.ASCII.GetBytes(vec);

                aes.Key = key;
                aes.IV = IV;
                ICryptoTransform transform = aes.CreateDecryptor(aes.Key, aes.IV);
                MemoryStream memDecryptStream = new MemoryStream();
                memDecryptStream.Write(ciphertext, 0, ciphertext.Length);
                CryptoStream cs_decrypt = new CryptoStream(memDecryptStream, transform, CryptoStreamMode.Write);

                byte[] plaintext = memDecryptStream.ToArray();
                //output = Encoding.ASCII.GetString(plaintext);
                output = utf8.GetString(plaintext);

            }
            catch (Exception e)
            {
                throw e;
            }
            return output;
        }
Esempio n. 26
0
        /// <summary>
        /// Decrypts a ProcessedPacket.
        /// </summary>
        /// <param name="InitializationVector">Initialization vec to be used by AES.</param>
        /// <param name="PrivateKey">Private key to be used.</param>
        /// <param name="PubKeyBlob">Public key blob to be used.</param>
        /// <param name="StreamToDecrypt">The stream to decrypt.</param>
        /// <returns>A decrypted stream.</returns>
        public static byte[] DecryptData(byte[] InitializationVector, CngKey PrivateKey, byte[] PubKeyBlob,
            byte[] DataToDecrypt)
        {
            using (var Algorithm = new ECDiffieHellmanCng(PrivateKey))
            {
                using (CngKey PubKey = CngKey.Import(PubKeyBlob,
                      CngKeyBlobFormat.EccPublicBlob))
                {
                    byte[] SymmetricKey = Algorithm.DeriveKeyMaterial(PubKey);
                    Console.WriteLine("DecryptedStream: Created symmetric key with " +
                        "public key information: {0}", Convert.ToBase64String(SymmetricKey));

                    AesCryptoServiceProvider AES = new AesCryptoServiceProvider();
                    AES.Key = SymmetricKey;
                    AES.IV = InitializationVector;
                    int NBytes = AES.BlockSize >> 3; //No idea...

                    using (ICryptoTransform Decryptor = AES.CreateDecryptor())
                    {
                        using (MemoryStream DecryptedStream = new MemoryStream())
                        {
                            var cs = new CryptoStream(DecryptedStream, Decryptor, CryptoStreamMode.Write);
                            cs.Write(DataToDecrypt, NBytes, DataToDecrypt.Length - NBytes);
                            cs.FlushFinalBlock();

                            return DecryptedStream.ToArray();
                        }
                    }
                }
            }
        }
Esempio n. 27
0
        static string DecryptStringFromBytes_Aes(byte[] cipherText, AesCryptoServiceProvider cryptoProvider)
        {
            // Check arguments.
            if (cipherText == null || cipherText.Length <= 0)
                throw new ArgumentNullException("cipherText");

            string plaintext = null;

            // Create a decrytor to perform the stream transform.
            ICryptoTransform decryptor = cryptoProvider.CreateDecryptor(cryptoProvider.Key, cryptoProvider.IV);

            // Create the streams used for decryption.
            using (MemoryStream msDecrypt = new MemoryStream(cipherText))
            {
                using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                {
                    using (StreamReader srDecrypt = new StreamReader(csDecrypt))
                    {

                        // Read the decrypted bytes from the decrypting stream
                        // and place them in a string.
                        plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }

            return plaintext;
        }
 ICryptoTransform CreateDecryptor(byte[] key, byte[] iv)
 {
     using (var provider = new AesCryptoServiceProvider {Padding = _paddingMode})
     {
         return provider.CreateDecryptor(key, iv);
     }
 }
Esempio n. 29
0
        public static string DecryptAES(byte[] data, byte[] key, byte[] IV)
        {
            string retVal = string.Empty;

            var tsp = new System.Security.Cryptography.AesCryptoServiceProvider();

            // default padding and mode
            tsp.Mode = CipherMode.CBC;
            tsp.Padding = PaddingMode.PKCS7;

            // get a crypt transform interface
            ICryptoTransform ct = tsp.CreateDecryptor(key, IV);

            // setup a memory stream
            MemoryStream ms = new MemoryStream();
            using (CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write))
            {
                // write the string through the crypto stream
                cs.Write(data, 0, data.Length);

                // flush
                cs.FlushFinalBlock();

                // convert the data in the memory stream to base64 text
                ms.Seek(0, SeekOrigin.Begin);

                var enc = ms.ToArray();//.TakeWhile(c => c > 16).ToArray();
                retVal = System.Text.Encoding.ASCII.GetString(enc, 0, enc.Length);
            }

            return retVal;
        }
Esempio n. 30
0
        public static byte[] decrypt(byte[] encrypted, byte[] Key, byte[] IV)
        {
            try
            {
                byte[] plain;
                int count;
                using (MemoryStream mStream = new MemoryStream(encrypted))
                {
                    using (AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider())
                    {
                        aesProvider.Mode = CipherMode.CBC;
                        using (CryptoStream cryptoStream = new CryptoStream(mStream,
                         aesProvider.CreateDecryptor(Key, IV), CryptoStreamMode.Read))
                        {
                            plain = new byte[encrypted.Length];
                            count = cryptoStream.Read(plain, 0, plain.Length);
                        }
                    }
                }

                byte[] returnValue = new byte[count];
                Array.Copy(plain, returnValue, count);
                return returnValue;
            }
            catch (Exception e)
            {
                Logger.log(e.StackTrace);
                throw e;
            }
        }
Esempio n. 31
0
        public static string Decrypt256FromHEX(string keyin, string ivin, string cipherText)
        {
            string result = string.Empty;
            try
            {
                byte[] key = Encoding.UTF8.GetBytes(keyin);
                byte[] iv = Encoding.UTF8.GetBytes(ivin);
                AesCryptoServiceProvider aesProvider = new AesCryptoServiceProvider();
                aesProvider.Mode = CipherMode.CBC;
                aesProvider.Padding = PaddingMode.Zeros;

                byte[] cipherTextBytesForDecrypt = HexStringToByteArray(cipherText);

                ICryptoTransform cryptoDecryptor = aesProvider.CreateDecryptor(key, iv);
                MemoryStream memStreamEncryptData = new MemoryStream(cipherTextBytesForDecrypt);
                CryptoStream rStream = new CryptoStream(memStreamEncryptData, cryptoDecryptor, CryptoStreamMode.Read);
                byte[] plainTextBytes = new byte[cipherTextBytesForDecrypt.Length];
                int decryptedByteCount = rStream.Read(plainTextBytes, 0, plainTextBytes.Length);
                memStreamEncryptData.Close();
                rStream.Close();
                result = Encoding.Default.GetString(plainTextBytes, 0, decryptedByteCount).Replace("\0", "");
            }
            catch (System.Security.Cryptography.CryptographicException)
            {
                result = cipherText;
            }
            return result;
        }
Esempio n. 32
0
        void recv(IAsyncResult res)
        {
            byte[] received;
            try
            {
                received = serverUdp.EndReceive(res, ref RemoteIp);
            }
            catch {
                return;
            }

            //check if connected and check that the ip corresponds
            if (connected && RemoteIp.Address.ToString() != connectedIp)
            {
                //if not just ignore
                //this avoids that a broadcast can pass
                return;
            }

            data = Encoding.UTF8.GetString(received);
            Console.WriteLine(data);

            try {
                //broadcast
                if (received[0] == BROADCAST)
                {
                    //Keyboard.SendKeyUp(0);
                    //TODO: if connected check if client is active
                    Console.WriteLine(RemoteIp.Address.ToString());
                    sendAlive();
                }
                else if (connected && (received[0] == CONNECTED || received[0] == CONNECTED_PASSWORD))
                {
                    if (usingPassword && received[0] == CONNECTED_PASSWORD)
                    {
                        ICryptoTransform decryptor = crypto.CreateDecryptor(crypto.Key, crypto.IV);
                        var origValue = decryptor.TransformFinalBlock(received, 1, received.Length - 1);
                        InputDispatcher.dispatch(origValue);
                    }
                    else if (!usingPassword && received[0] == CONNECTED)
                    {
                        byte[] destfoo = new byte[received.Length - 1];
                        Array.Copy(received, 1, destfoo, 0, received.Length - 1);
                        InputDispatcher.dispatch(destfoo);
                    }
                    else
                    {
                        //TODO: codice errore
                        sendMessage(RemoteIp.Address.ToString(), CONNECTION_ERROR);
                    }
                }
            }
            catch (Exception e)
            {
                Console.Write(e.StackTrace);
            }

            serverUdp.BeginReceive(new AsyncCallback(recv), null);
        }
Esempio n. 33
0
        byte[] Transform(byte[] dataBytes, byte[] passwordBytes, bool encrypt)
        {
            /// <summary>Encrypt by using AES-256 algorithm.</summary>
            // Create an instance of the AES class.
            var cipher = new System.Security.Cryptography.AesCryptoServiceProvider();
            // Calculate salt to make it harder to guess key by using a dictionary attack.
            var hmac = new System.Security.Cryptography.HMACSHA1(passwordBytes);
            var salt = hmac.ComputeHash(passwordBytes);
            // Generate Secret Key from the password and salt.
            // Note: Set number of iterations to 10 in order for JavaScript example to work faster.
            var secretKey = new System.Security.Cryptography.Rfc2898DeriveBytes(passwordBytes, salt, 10);
            // Create a encryptor from the existing SecretKey bytes by using
            // 32 bytes (256 bits) for the secret key and
            // 16 bytes (128 bits) for the initialization vector (IV).
            var key = secretKey.GetBytes(32);
            var iv  = secretKey.GetBytes(16);
            // Get cryptor as System.Security.Cryptography.ICryptoTransform class.
            var cryptor = encrypt
                                ? cipher.CreateEncryptor(key, iv)
                                : cipher.CreateDecryptor(key, iv);
            // Create new Input.
            var inputBuffer = new byte[dataBytes.Length];

            // Copy data bytes to input buffer.
            System.Buffer.BlockCopy(dataBytes, 0, inputBuffer, 0, inputBuffer.Length);
            // Create a MemoryStream to hold the output bytes.
            var stream = new System.IO.MemoryStream();
            // Create a CryptoStream through which we are going to be processing our data.
            var mode         = System.Security.Cryptography.CryptoStreamMode.Write;
            var cryptoStream = new System.Security.Cryptography.CryptoStream(stream, cryptor, mode);

            // Start the crypting process.
            cryptoStream.Write(inputBuffer, 0, inputBuffer.Length);
            // Finish crypting.
            cryptoStream.FlushFinalBlock();
            // Convert data from a memoryStream into a byte array.
            var outputBuffer = stream.ToArray();

            // Close both streams.
            stream.Close();
            cryptoStream.Close();
            return(outputBuffer);
        }
Esempio n. 34
0
        private static byte[] _DecryptData(byte[] data, byte[] IV, int bitLength, byte[] passphrase)
        {
            var aes = new System.Security.Cryptography.AesCryptoServiceProvider();
            var iv  = new byte[16];                                  //always 16 for AES
            var key = new byte[IV.Length == 7 ? 32 : IV.Length / 8]; //HACK: for "AES-56", convert to AES-256
            var ret = new byte[data.Length];

            //Pad the IV if necessary
            Array.Copy(IV, iv, IV.Length);

            //Derive the key
            var derived = _DeriveEncryptionKey(bitLength, passphrase);

            Array.Copy(derived, key, derived.Length);

            //Decrypt it!
            aes.CreateDecryptor(key, iv).TransformBlock(data, 0, data.Length, ret, 0);

            return(ret);
        }
Esempio n. 35
0
        public static byte[] Decrypt(string privateKey, byte[] data)
        {
            using (var aes = new AesCryptoServiceProvider())
            {
                var iv  = new byte[128];
                var key = new byte[128];

                Buffer.BlockCopy(data, 0, iv, 0, 128);
                Buffer.BlockCopy(data, 128, key, 0, 128);

                using (var encryptor = aes.CreateDecryptor(Rsa.Decrypt(privateKey, key), Rsa.Decrypt(privateKey, iv)))
                    using (var src = new MemoryStream(data, writable: false))
                        using (var dst = new MemoryStream())
                        {
                            src.Seek(256, SeekOrigin.Begin);
                            using (var cs = new CryptoStream(src, encryptor, CryptoStreamMode.Read))
                            {
                                cs.CopyTo(dst);
                            }
                            return(dst.ToArray());
                        }
            }
        }