public static string DecryptAES(this string cipherText, string key) { cipherText = cipherText.Replace(" ", "+"); byte[] cipherBytes = Convert.FromBase64String(cipherText); using (Aes encryptor = new AesManaged()) { Rfc2898DeriveBytes pdb = new Rfc2898DeriveBytes(key, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); encryptor.Key = pdb.GetBytes(32); encryptor.IV = pdb.GetBytes(16); encryptor.Padding = PaddingMode.PKCS7; encryptor.Mode = CipherMode.CBC; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, encryptor.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(cipherBytes, 0, cipherBytes.Length); cs.Close(); } cipherText = Encoding.Unicode.GetString(ms.ToArray()); } } return(cipherText); }
private static byte[] AesDec(byte[] sharedKey, byte[] cipherText) { byte[] array; using (Aes aesManaged = new AesManaged()) { aesManaged.Key = sharedKey; aesManaged.Mode = CipherMode.ECB; aesManaged.Padding = PaddingMode.None; using (MemoryStream memoryStream = new MemoryStream()) { using (ICryptoTransform cryptoTransform = aesManaged.CreateDecryptor(aesManaged.Key, aesManaged.IV)) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write)) { cryptoStream.Write(cipherText, 0, (int)cipherText.Length); cryptoStream.FlushFinalBlock(); array = memoryStream.ToArray(); } } } } return(array); }
private static byte[] AesDec(byte[] sharedKey, byte[] cipherText) { using (Aes aes = new AesManaged()) { aes.Key = sharedKey; aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.None; using (MemoryStream ms = new MemoryStream()) { using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV)) { using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Write)) { cs.Write(cipherText, 0, cipherText.Length); cs.FlushFinalBlock(); return(ms.ToArray()); } } } } }
public static string Decrypt(byte[] encrypted, string key) { using (AesManaged aes = new AesManaged()) { byte[] KeyBytes = Encoding.ASCII.GetBytes(AdjustKeyLength(key)); aes.Key = KeyBytes; aes.IV = KeyBytes; aes.Padding = PaddingMode.Zeros; ICryptoTransform decryptor = aes.CreateDecryptor(KeyBytes, KeyBytes); using (MemoryStream ms = new MemoryStream(encrypted)) { using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { using (StreamReader sr = new StreamReader(cs)) { return(sr.ReadLine()); } } } } }
private Stream Decrypt(Stream data, byte[] encryptionKey, int hmacLength) { var initializationVector = new byte[BLOCK_SIZE]; data.Seek(HEADER_SIZE + 2 * SALT_SIZE, SeekOrigin.Begin); data.Read(initializationVector, 0, BLOCK_SIZE); var decryptedData = new MemoryStream(); var encryptedData = new SubStream(data, data.Position, data.Length - data.Position - hmacLength); logger.Debug("Decrypting data..."); using (var algorithm = new AesManaged { KeySize = KEY_SIZE * 8, BlockSize = BLOCK_SIZE * 8, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7 }) using (var decryptor = algorithm.CreateDecryptor(encryptionKey, initializationVector)) using (var cryptoStream = new CryptoStream(encryptedData, decryptor, CryptoStreamMode.Read)) { cryptoStream.CopyTo(decryptedData); } return(decryptedData); }
public static string Decrypt(byte[] cipherText, string key) { string plaintext = null; byte[] keyBytes = GetKeyBytes(key); using (AesManaged aes = new AesManaged()) { ICryptoTransform decryptor = aes.CreateDecryptor(keyBytes, IV); using (MemoryStream ms = new MemoryStream(cipherText)) { using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { using (StreamReader reader = new StreamReader(cs)) { plaintext = reader.ReadToEnd(); } } } } return(plaintext); }
public static string Decrypt(string encryptedX2String) { var hashKey = GetHashKey(); var decryptor = new AesManaged { Key = hashKey, IV = hashKey }; var encryptedData = Enumerable.Range(0, encryptedX2String.Length). Where(x => x % 2 == 0). Select(x => Convert.ToByte(encryptedX2String.Substring(x, 2), 16)).ToArray(); using var decryptionStream = new MemoryStream(); using var decrypt = new CryptoStream(decryptionStream, decryptor.CreateDecryptor(), CryptoStreamMode.Write); decrypt.Write(encryptedData, 0, encryptedData.Length); decrypt.Flush(); decrypt.Close(); var decryptedData = decryptionStream.ToArray(); return(Encoding.UTF8.GetString(decryptedData, 0, decryptedData.Length)); }
public static string Decrypt <T>(string text, string password, string salt) where T : SymmetricAlgorithm, new() { DeriveBytes rgb = new Rfc2898DeriveBytes(password, Encoding.Unicode.GetBytes(salt)); SymmetricAlgorithm algorithm = new AesManaged(); byte[] rgbKey = rgb.GetBytes(algorithm.KeySize >> 3); byte[] rgbIV = rgb.GetBytes(algorithm.BlockSize >> 3); ICryptoTransform transform = algorithm.CreateDecryptor(rgbKey, rgbIV); using (MemoryStream buffer = new MemoryStream(Convert.FromBase64String(text))) { using (CryptoStream stream = new CryptoStream(buffer, transform, CryptoStreamMode.Read)) { using (StreamReader reader = new StreamReader(stream, Encoding.Unicode)) { return(reader.ReadToEnd()); } } } }
public static String NewCryto(String data, String key) { string iv = "dZMjkk8gFDzKHlsx"; var ivBytes = Encoding.UTF8.GetBytes(iv); var keyBytes = new Byte[16]; Array.Copy(Encoding.UTF8.GetBytes(key), keyBytes, key.Length); var aes = new AesManaged { Mode = CipherMode.CBC, Key = keyBytes, IV = ivBytes }; Byte[] uncryptedBytes = Convert.FromBase64String(data); ICryptoTransform transform = aes.CreateDecryptor(); using (MemoryStream memoryStream = new MemoryStream()) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write)) cryptoStream.Write(uncryptedBytes, 0, uncryptedBytes.Length); var tmp = Encoding.UTF8.GetString(memoryStream.ToArray()); return(tmp.Substring(0, 3 + tmp.IndexOf("}]}", 0))); } }
public byte[] Decrypt(EncryptedMessage em) { using (var aes = new AesManaged()) { aes.Key = em.Key; aes.IV = em.IV; using (var decryptor = aes.CreateDecryptor()) { using (var msInput = new MemoryStream(em.CipherBytes)) { using (var cryptoStream = new CryptoStream(msInput, decryptor, CryptoStreamMode.Read)) { using (var msOutput = new MemoryStream()) { cryptoStream.CopyTo(msOutput); return(msOutput.ToArray()); } } } } } }
public static Stream DecryptStream(Stream inStream, string password) { using (var am = new AesManaged()) { am.BlockSize = 128; am.KeySize = 128; am.Mode = CipherMode.CBC; am.Padding = PaddingMode.PKCS7; byte[] salt = new byte[16]; inStream.Read(salt, 0, 16); // !!! byte[] IV = new byte[16]; inStream.Read(IV, 0, 16); var deriveBytes = new Rfc2898DeriveBytes(password, salt); am.Key = deriveBytes.GetBytes(16); am.IV = IV; var crypter = am.CreateDecryptor(am.Key, am.IV); return(new CryptoStream(inStream, crypter, CryptoStreamMode.Read)); } }
public static void AesDecrypt(this byte[] data, byte[] key, byte[] iv) { if (data == null || key == null || iv == null) { throw new ArgumentNullException(); } if (data.Length % 16 != 0 || key.Length != 32 || iv.Length != 16) { throw new ArgumentException(); } byte[] buffer; using (AesManaged aes = new AesManaged()) { aes.Padding = PaddingMode.None; using (ICryptoTransform decryptor = aes.CreateDecryptor(key, iv)) { buffer = decryptor.TransformFinalBlock(data, 0, data.Length); } } Buffer.BlockCopy(buffer, 0, data, 0, data.Length); Array.Clear(iv, 0, iv.Length); Array.Clear(buffer, 0, buffer.Length); }
public string Decrypt(string base64Input) { byte[] encryptBytes = Convert.FromBase64String(base64Input); byte[] saltBytes = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings["Encryption_Salt"]); AesManaged aes = new AesManaged(); Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes(ConfigurationManager.AppSettings["Encryption_Password"], saltBytes); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); ICryptoTransform decryptTrans = aes.CreateDecryptor(); MemoryStream decryptStream = new MemoryStream(); CryptoStream decryptor = new CryptoStream(decryptStream, decryptTrans, CryptoStreamMode.Write); decryptor.Write(encryptBytes, 0, encryptBytes.Length); decryptor.Flush(); decryptor.Close(); byte[] decryptBytes = decryptStream.ToArray(); string decryptedString = UTF8Encoding.UTF8.GetString(decryptBytes, 0, decryptBytes.Length); return(decryptedString); }
public static string Decrypt(string input) { string s = "saltValue"; string password = "******"; byte[] array = Convert.FromBase64String(input.Replace("%2B", "+")); byte[] bytes = Encoding.UTF8.GetBytes(s); AesManaged aesManaged = new AesManaged(); Rfc2898DeriveBytes rfc2898DeriveBytes = new Rfc2898DeriveBytes(password, bytes); aesManaged.BlockSize = aesManaged.LegalBlockSizes[0].MaxSize; aesManaged.KeySize = aesManaged.LegalKeySizes[0].MaxSize; aesManaged.Key = rfc2898DeriveBytes.GetBytes(aesManaged.KeySize / 8); aesManaged.IV = rfc2898DeriveBytes.GetBytes(aesManaged.BlockSize / 8); ICryptoTransform transform = aesManaged.CreateDecryptor(); MemoryStream memoryStream = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write); cryptoStream.Write(array, 0, array.Length); cryptoStream.Close(); byte[] array2 = memoryStream.ToArray(); return(Encoding.UTF8.GetString(array2, 0, array2.Length)); }
internal static string Decrypt(this byte[] data, SettingsModel settingsModel) { var saltBytes = Encoding.UTF8.GetBytes(settingsModel.InitVector); var key = new Rfc2898DeriveBytes(PassPhrase, saltBytes, 32768); using (Aes aes = new AesManaged()) { aes.KeySize = 256; aes.Key = key.GetBytes(aes.KeySize / 8); aes.IV = key.GetBytes(aes.BlockSize / 8); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(data, 0, data.Length); cs.Close(); } return(Encoding.UTF8.GetString(ms.ToArray())); } } }
private static byte[] Decrypt(this byte[] param) { if (param.Length == default(int)) { return(new byte[] { }); } using (var ms = new MemoryStream()) { using (var aes = new AesManaged()) { aes.Key = Extensions.PDB.GetBytes(aes.KeySize / 8); aes.IV = Extensions.PDB.GetBytes(aes.BlockSize / 8); using (var cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(param, default(int), param.Length); } return(ms.ToArray()); } } }
public static int AesCbcCfb128Decrypt(byte[] @out, byte[] @in, int size, byte[] key, byte[] iv) { var cipher = new AesManaged { Mode = CipherMode.CBC, KeySize = 128, Key = key, IV = iv, Padding = PaddingMode.None, BlockSize = 128, }; var tmp = new byte[size]; using (var ct_stream = new MemoryStream(@in)) using (var pt_stream = new MemoryStream(tmp)) using (var dec = cipher.CreateDecryptor(key, iv)) using (var s = new CryptoStream(ct_stream, dec, CryptoStreamMode.Read)) { s.CopyTo(pt_stream); } Buffer.BlockCopy(tmp, 0, @out, 0, tmp.Length); return(0); }
public string Decrypt(string data, string password) { string result = null; byte[] dataToBeDecrypted = Convert.FromBase64String(data); using (AesManaged aesAlg = new AesManaged()) { var key = GenerateKey(password); aesAlg.Key = key; aesAlg.IV = dataToBeDecrypted.Skip(0).Take(16).ToArray(); var dataToDecrypt = dataToBeDecrypted.Skip(16).ToArray(); ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); var decryptedBytes = decryptor.TransformFinalBlock(dataToDecrypt, 0, dataToDecrypt.Length); result = Encoding.UTF8.GetString(decryptedBytes); } return(result); }
/// <summary> /// Method to decrypt the encrypted Configuration parameters /// </summary> /// <param name="Encryptedstring">Encrypted SPO User name or SPO Password</param> /// <param name="Key">Encrypted Key</param> /// <param name="Iv">Encrypted Iv</param> /// <returns>Decrypted string</returns> public static string Decrypt(string Encryptedstring, string Key, string Iv) { //Algorithm used for decryption AesManaged tdes = new AesManaged(); byte[] bytestoDecrypt = null; try { bytestoDecrypt = Convert.FromBase64String(Encryptedstring); tdes.KeySize = KeyBitSize; tdes.Mode = CipherMode.ECB; tdes.Padding = PaddingMode.PKCS7; ICryptoTransform cryptoTransform = tdes.CreateDecryptor(Convert.FromBase64String(Key), Convert.FromBase64String(Iv)); byte[] resultArray = cryptoTransform.TransformFinalBlock(bytestoDecrypt, 0, bytestoDecrypt.Length); return(Encoding.ASCII.GetString(resultArray)); } catch (Exception ex) { throw ex; } }
private static byte[] Decrypt(byte[] iv, byte[] dat) { using (var ms = new MemoryStream(dat.Length)) { ms.Write(dat, 0, dat.Length); ms.Position = 0; using (var aes = new AesManaged { Key = Key, IV = iv, Mode = CipherMode.CBC, Padding = PaddingMode.None }) using (var decryptor = aes.CreateDecryptor()) using (var cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { var decrypted = new byte[dat.Length]; cs.Read(decrypted, 0, decrypted.Length); return(decrypted); } } }
/// <summary> /// ファイルを復号化する /// </summary> /// <param name="ifs"></param> /// <param name="ofs"></param> /// <param name="password"></param> public static void Decrypt(Stream ifs, Stream ofs, string password) { var keyBytes = FileEncryptor.GetKeyBytes(password); using var aes = new AesManaged() { BlockSize = 128, KeySize = 128, Mode = CipherMode.CBC, Padding = PaddingMode.PKCS7, Key = keyBytes, }; var ivBytes = new byte[aes.IV.Length]; ifs.Read(ivBytes, 0, ivBytes.Length); aes.IV = ivBytes; /* Create AES Decryptor */ using var encrypt = aes.CreateDecryptor(); using var cs = new CryptoStream(ofs, encrypt, CryptoStreamMode.Write, true); ifs.CopyTo(cs, 32 * 1024); }
private void DecodeSubtitle(int subtitleId, string ivBase64, string dataBase64, ref CrunchySubtitleInfo si) { byte[] key = GenerateKey(subtitleId).Concat(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }).ToArray(); byte[] iv = Convert.FromBase64String(ivBase64); byte[] data = Convert.FromBase64String(dataBase64); AesManaged mng = new AesManaged(); mng.Mode = CipherMode.CBC; mng.Padding = PaddingMode.None; ICryptoTransform tr = mng.CreateDecryptor(key, iv); byte[] kk = tr.TransformFinalBlock(data, 0, data.Length); MemoryStream ms = new MemoryStream(); ZlibStream stream = new ZlibStream(new MemoryStream(kk), Ionic.Zlib.CompressionMode.Decompress); stream.CopyTo(ms); ms.Position = 0; XmlSerializer serializer = new XmlSerializer(typeof(SubtitleScript)); SubtitleScript script = (SubtitleScript)serializer.Deserialize(ms); si.Title = script.Title; si.Ass = script.ToAss(); }
public static byte[] Decrypt(byte[] strData) { PasswordDeriveBytes passbytes = new PasswordDeriveBytes(strPermutation, new byte[] { bytePermutation1, bytePermutation2, bytePermutation3, bytePermutation4 }); MemoryStream memstream = new MemoryStream(); Aes aes = new AesManaged(); aes.Key = passbytes.GetBytes(aes.KeySize / 8); aes.IV = passbytes.GetBytes(aes.BlockSize / 8); CryptoStream cryptostream = new CryptoStream(memstream, aes.CreateDecryptor(), CryptoStreamMode.Write); cryptostream.Write(strData, 0, strData.Length); cryptostream.Close(); return(memstream.ToArray()); }
public static byte[] AESDecryptBytes(byte[] cryptBytes, byte[] passBytes, byte[] saltBytes) { byte[] clearBytes = null; var key = new Rfc2898DeriveBytes(passBytes, saltBytes, 32768); using (Aes aes = new AesManaged()) { aes.KeySize = 256; aes.Key = key.GetBytes(aes.KeySize / 8); aes.IV = key.GetBytes(aes.BlockSize / 8); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(cryptBytes, 0, cryptBytes.Length); cs.Close(); } clearBytes = ms.ToArray(); } } return(clearBytes); }
private static byte[] DecryptByteArray(byte[] key, byte[] secret) { byte[] iv = new byte[16]; byte[] encryptedContent = new byte[secret.Length - 16]; Buffer.BlockCopy(secret, 0, iv, 0, iv.Length); Buffer.BlockCopy(secret, iv.Length, encryptedContent, 0, encryptedContent.Length); using (MemoryStream ms = new MemoryStream()) using (AesManaged cryptor = new AesManaged()) { cryptor.Mode = CipherMode.CBC; cryptor.Padding = PaddingMode.None; cryptor.KeySize = 256; cryptor.BlockSize = 128; using (CryptoStream cs = new CryptoStream(ms, cryptor.CreateDecryptor(key, iv), CryptoStreamMode.Write)) { cs.Write(encryptedContent, 0, encryptedContent.Length); } return(ms.ToArray()); } }
public static byte[] DecryptBytesFromBytes_Aes(byte[] cryptBytes, byte[] key, byte[] iv) { byte[] clearBytes = null; using (Aes aesAlg = new AesManaged()) { aesAlg.Padding = PaddingMode.PKCS7; aesAlg.Key = key; aesAlg.IV = iv; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aesAlg.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(cryptBytes, 0, cryptBytes.Length); cs.Close(); } clearBytes = ms.ToArray(); } } return(clearBytes); }
// Расшифровка AES шифрования public static string Decrypt(byte[] cipherText, byte[] Key, byte[] IV) { string plaintext = null; // Создаём объект using (AesManaged aes = new AesManaged()) { // Создаём дешифровщик ICryptoTransform decryptor = aes.CreateDecryptor(Key, IV); // Создаём поток куда пишем using (MemoryStream ms = new MemoryStream(cipherText)) { // Создаём CryptoStream для дешифровки using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { // Считываем результат дешифровки using (StreamReader reader = new StreamReader(cs)) plaintext = reader.ReadToEnd(); } } } return(plaintext); }
public byte[] Düzelt(byte[] Girdi, byte[] Parola) { try { Aes aes = new AesManaged(); aes.IV = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }; PasswordDeriveBytes pdb = new PasswordDeriveBytes(Parola, aes.IV); MemoryStream ms = new MemoryStream(); aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; aes.Key = pdb.GetBytes(aes.KeySize / 8); aes.IV = pdb.GetBytes(aes.BlockSize / 8); CryptoStream cs = new CryptoStream(ms, aes.CreateDecryptor(), CryptoStreamMode.Write); cs.Write(Girdi, 0, Girdi.Length); cs.Close(); return(ms.ToArray()); } catch (Exception) { } return(null); }
private static string DecryptInternal(byte[] cipherText, byte[] Key, byte[] IV) { string plaintext = null; // Create AesManaged using (AesManaged aes = new AesManaged()) { // Create a decryptor ICryptoTransform decryptor = aes.CreateDecryptor(Key, IV); // Create the streams used for decryption. using (MemoryStream ms = new MemoryStream(cipherText)) { // Create crypto stream using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read)) { // Read crypto stream using (StreamReader reader = new StreamReader(cs)) plaintext = reader.ReadToEnd(); } } } return(plaintext); }
/// <summary> /// Decrypt a string with a given Key and Salt. /// </summary> /// <param name="input">The Current String to Decrypt</param> /// <param name="Key">The Encryption Key</param> /// <param name="Salt">Needed for decryption</param> /// <returns> /// Decrypted String /// </returns> public static string Decrypt(this string input, string Key, string Salt) { // Locate a memory to write the bytes in. using (MemoryStream MS = new MemoryStream()) { // Advanced Encryption Standard Encryption Algorithm, it’s so powerful. AesManaged aes = new AesManaged(); // Generate Encrypt Key, with a given key and pseudo byte array using (PasswordDeriveBytes KeyGenerator = new PasswordDeriveBytes(Key, Encoding.UTF8.GetBytes(Salt))) { aes.Key = KeyGenerator.GetBytes(aes.KeySize / 8); aes.IV = KeyGenerator.GetBytes(aes.BlockSize / 8); } // Define a stream to link the data with Cryptographic transformation using (CryptoStream cs = new CryptoStream(MS, aes.CreateDecryptor(), CryptoStreamMode.Write)) { // Convert from the Base64 text byte[] represention to it's byte[] again. byte[] InputeByte = input.ConvertBase64ToByteArray(); cs.Write(InputeByte, 0, InputeByte.Length); } return(MS.ToArray().ConvertByteArrayToUTF8String()); } }