protected static string DecryptString(string InputText, string Password) { try { RijndaelManaged RijndaelCipher = new RijndaelManaged(); byte[] EncryptedData = Convert.FromBase64String(InputText); byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString()); PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt); // Create a decryptor from the existing SecretKey bytes. ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(16), SecretKey.GetBytes(16)); MemoryStream memoryStream = new MemoryStream(EncryptedData); // Create a CryptoStream. (always use Read mode for decryption). CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read); // Since at this point we don't know what the size of decrypted data // will be, allocate the buffer long enough to hold EncryptedData; // DecryptedData is never longer than EncryptedData. byte[] PlainText = new byte[EncryptedData.Length]; // Start decrypting. int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length); memoryStream.Close(); cryptoStream.Close(); // Convert decrypted data into a string. string DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount); // Return decrypted string. return DecryptedData; } catch (Exception exception) { return (exception.Message); } }
/// <summary> /// 문자열을 복호화 /// </summary> /// <param name="InputText"></param> /// <param name="Password"></param> /// <returns></returns> internal string GetDecryptedString(string InputText, string Password) { byte[] EncryptedData = Convert.FromBase64String(InputText); #region 복호화 키 객체 만들기 RijndaelManaged RijndaelCipher = new RijndaelManaged(); byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString()); PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt); // Decryptor 객체를 만듭니다. ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16)); #endregion #region 복호화 byte[] PlainText = null; int DecryptedCount = 0; using (MemoryStream memoryStream = new MemoryStream(EncryptedData)) { using (CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read)) { /* * 복호화된 데이터를 담을 바이트 배열을 선언합니다. 길이는 알 수 없지만, 일단 복호화되기 전의 데이터의 길이보다는 길지 않을 것이기 때문에 그 길이로 선언합니다 */ PlainText = new byte[EncryptedData.Length]; // 복호화 시작 DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length); } } // 복호화된 데이터를 문자열로 바꿉니다. string DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount); //복호화 키 객체 해제 Decryptor.Dispose(); #endregion return DecryptedData; }
public static void EncryptData(String inName, String outName, String password) { FileStream fin = new FileStream(inName, FileMode.Open, FileAccess.Read); FileStream fout = new FileStream(outName, FileMode.OpenOrCreate, FileAccess.Write); PasswordDeriveBytes pdb = new PasswordDeriveBytes(password, keySalt); Rijndael alg = Rijndael.Create(); alg.Key = pdb.GetBytes(32); alg.IV = pdb.GetBytes(16); CryptoStream cs = new CryptoStream(fout, alg.CreateEncryptor(), CryptoStreamMode.Write); int bufferLen = 4096; byte[] buffer = new byte[bufferLen]; int bytesRead; do { bytesRead = fin.Read(buffer, 0, bufferLen); cs.Write(buffer, 0, bytesRead); } while(bytesRead != 0); cs.Close(); fin.Close(); }
public string Encrypt(string clearText) { passwordDeriveBytes = new PasswordDeriveBytes(key, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); var clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText); var encryptedData = Encrypt(clearBytes, passwordDeriveBytes.GetBytes(32), passwordDeriveBytes.GetBytes(16)); return Convert.ToBase64String(encryptedData); }
/// <summary> /// Encrypt string /// </summary> /// <param name="queryString"></param> /// <returns></returns> public static string EncryptString(string inputString) { try { if (inputString != null) { // First we need to turn the input string into a byte array. byte[] queryStringBytes = Encoding.UTF8.GetBytes(inputString);//Encoding.Unicode.GetBytes(queryString) ovo je izbacivalo pogrešku; // Then, we need to turn the password into Key and IV. We are using salt to make it harder to guess our key // using a dictionary attack - trying to guess a password by enumerating all possible words. PasswordDeriveBytes pdb = new PasswordDeriveBytes(passwordStr, Encoding.UTF8.GetBytes(saltStr)); // Now get the key/IV and do the encryption using the function that accepts byte arrays. // Using PasswordDeriveBytes object we are first getting 32 bytes for the Key (the default Rijndael key length is 256bit = 32bytes) // and then 16 bytes for the IV. IV should always be the block size, which is by default 16 bytes (128 bit) for Rijndael. byte[] encryptedData = Encrypt(queryStringBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return Convert.ToBase64String(encryptedData); } else return null; } catch { return null; } finally { } }
public byte[] DecryptBinary( byte [] encryptedBytes, string key ) { RijndaelManaged RijndaelCipher = new RijndaelManaged (); byte [] EncryptedData = encryptedBytes; byte [] Salt = Encoding.ASCII.GetBytes ( key.Length.ToString () ); PasswordDeriveBytes SecretKey = new PasswordDeriveBytes ( key, Salt ); // Create a decryptor from the existing SecretKey bytes. ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor ( SecretKey.GetBytes ( 32 ), SecretKey.GetBytes ( 16 ) ); MemoryStream memoryStream = new MemoryStream ( EncryptedData ); // Create a CryptoStream. (always use Read mode for decryption). CryptoStream cryptoStream = new CryptoStream ( memoryStream, Decryptor, CryptoStreamMode.Read ); // Since at this point we don't know what the size of decrypted data // will be, allocate the buffer long enough to hold EncryptedData; // DecryptedData is never longer than EncryptedData. byte [] PlainText = new byte [ EncryptedData.Length ]; // Start decrypting. int DecryptedCount = cryptoStream.Read ( PlainText, 0, PlainText.Length ); memoryStream.Close (); cryptoStream.Close (); // Return decrypted string. return PlainText; }
public static string omDecryptEx(string strEncryptedString) { if (!string.IsNullOrEmpty(strEncryptedString)) { try { string strPassword = "******"; RijndaelManaged managed = new RijndaelManaged(); byte[] buffer = Convert.FromBase64String(strEncryptedString); byte[] rgbSalt = Encoding.ASCII.GetBytes(strPassword.Length.ToString()); PasswordDeriveBytes bytes = new PasswordDeriveBytes(strPassword, rgbSalt); ICryptoTransform transform = managed.CreateDecryptor(bytes.GetBytes(0x20), bytes.GetBytes(0x10)); MemoryStream stream = new MemoryStream(buffer); CryptoStream stream2 = new CryptoStream(stream, transform, CryptoStreamMode.Read); byte[] buffer3 = new byte[buffer.Length]; int count = stream2.Read(buffer3, 0, buffer3.Length); stream.Close(); stream2.Close(); return Encoding.Unicode.GetString(buffer3, 0, count); } catch { throw new SecurityException("Could not decrypt string"); } } return string.Empty; }
private static string Decrypt(string inputText) { RijndaelManaged rijndaelCipher = new RijndaelManaged(); Byte[] encryptedData = Convert.FromBase64String(inputText); //Rfc2898DeriveBytes pwdGen = new Rfc2898DeriveBytes(ENCRYPTION_KEY, ENCRYPTION_SALT, 1000); PasswordDeriveBytes pwdGen = new PasswordDeriveBytes(ENCRYPTION(), ENCRYPTION_SALT()); byte[] Key = pwdGen.GetBytes(32); byte[] IV = pwdGen.GetBytes(16); using (ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(Key, IV)) { using (MemoryStream memoryStream = new MemoryStream(encryptedData)) { using ( CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read) ) { byte[] plainText = new Byte[encryptedData.Length]; int decryptedCount = cryptoStream.Read(plainText, 0, plainText.Length); return Encoding.Unicode.GetString(plainText, 0, decryptedCount); } } } }
/// <summary> /// Passwort-Verschlüsselung /// </summary> /// <param name="text"></param> /// <returns></returns> public static string Encrypt(string text) { if (text.Length < 1) { return text; } string code = ""; System.Text.UnicodeEncoding enc = new System.Text.UnicodeEncoding(); byte[] bytes = enc.GetBytes(text); PasswordDeriveBytes pdb = new PasswordDeriveBytes(code, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); using (MemoryStream ms = new MemoryStream()) { Rijndael alg = Rijndael.Create(); alg.Key = pdb.GetBytes(32); alg.IV = pdb.GetBytes(16); using (CryptoStream cs = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(bytes, 0, bytes.Length); } bytes = ms.ToArray(); } return Convert.ToBase64String(bytes); }
/** * AES 256 bits encrypt with salt **/ private static byte[] Encrypt(byte[] plainTextBytes, byte[] passwordBytes, byte[] saltBytes) { byte[] cipherTextBytes = null; ICryptoTransform encryptor = null; PasswordDeriveBytes key = new PasswordDeriveBytes(passwordBytes, saltBytes, DEFAULT_HASH_ALGORITHM, PASSWORD_ITERATIONS); RijndaelManaged AES = new RijndaelManaged(); AES.KeySize = DEFAULT_KEY_SIZE; AES.Mode = CipherMode.CBC; // Get Key And IV From Password And Salt AES.Key = key.GetBytes(AES.KeySize / 8); AES.IV = key.GetBytes(AES.BlockSize / 8); encryptor = AES.CreateEncryptor(); MemoryStream memoryStream = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write); cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); cipherTextBytes = memoryStream.ToArray(); memoryStream.Close(); cryptoStream.Close(); return cipherTextBytes; }
public static string EncryptString(string InputText, string Password) { RijndaelManaged RijndaelCipher = new RijndaelManaged(); byte[] PlainText = System.Text.Encoding.Unicode.GetBytes(InputText); byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString()); PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt); ICryptoTransform Encryptor = RijndaelCipher.CreateEncryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16)); MemoryStream memoryStream = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(memoryStream, Encryptor, CryptoStreamMode.Write); cryptoStream.Write(PlainText, 0, PlainText.Length); cryptoStream.FlushFinalBlock(); byte[] CipherBytes = memoryStream.ToArray(); memoryStream.Close(); cryptoStream.Close(); string EncryptedData = Convert.ToBase64String(CipherBytes); // Return encrypted string. return EncryptedData; }
/// <summary> /// Triple DES Descrypt /// </summary> /// <param name="input">String to decrypt</param> /// <param name="key">Encryption Key</param> /// <returns></returns> public static string Decrypt(string input, string key) { TripleDESCryptoServiceProvider crp =new TripleDESCryptoServiceProvider(); System.Text.UnicodeEncoding uEncode = new UnicodeEncoding(); System.Text.ASCIIEncoding aEncode =new ASCIIEncoding(); Byte[] bytCipherText = System.Convert.FromBase64String(input); MemoryStream stmPlainText =new MemoryStream(); MemoryStream stmCipherText = new MemoryStream(bytCipherText); Byte[] slt= {0x12}; PasswordDeriveBytes pdb = new PasswordDeriveBytes(key, slt); Byte[] bytDerivedKey = pdb.GetBytes(24); crp.Key = bytDerivedKey; crp.IV = pdb.GetBytes(8); CryptoStream csDecrypted = new CryptoStream(stmCipherText, crp.CreateDecryptor(), CryptoStreamMode.Read); StreamWriter sw = new StreamWriter(stmPlainText); StreamReader sr = new StreamReader(csDecrypted); sw.Write(sr.ReadToEnd()); sw.Flush(); crp.Clear(); return uEncode.GetString(stmPlainText.ToArray()); }
// Decrypt a string into a string using a password // Uses Decrypt(byte[], byte[], byte[]) public static string Decrypt(string cipherText, string Password) { // First we need to turn the input string into a byte array. // We presume that Base64 encoding was used byte[] cipherBytes = Convert.FromBase64String(cipherText); // Then, we need to turn the password into Key and IV // We are using salt to make it harder to guess our key using a dictionary attack - // trying to guess a password by enumerating all possible words. PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); // Now get the key/IV and do the decryption using the function that accepts byte arrays. // Using PasswordDeriveBytes object we are first getting 32 bytes for the Key // (the default Rijndael key length is 256bit = 32bytes) and then 16 bytes for the IV. // IV should always be the block size, which is by default 16 bytes (128 bit) for Rijndael. // If you are using DES/TripleDES/RC2 the block size is 8 bytes and so should be the IV size. // You can also read KeySize/BlockSize properties off the algorithm to find out the sizes. byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16)); // Now we need to turn the resulting byte array into a string. // A common mistake would be to use an Encoding class for that. It does not work // because not all byte values can be represented by characters. // We are going to be using Base64 encoding that is designed exactly for what we are // trying to do. return System.Text.Encoding.Unicode.GetString(decryptedData); }
public static String Cryption(string text, string password, bool boolCrypt) { byte[] utf8_Salt = new byte[] { 0x26, 0x19, 0x81, 0x4E, 0xA0, 0x6D, 0x95, 0x34, 0x26, 0x75, 0x64, 0x05, 0xF6 }; PasswordDeriveBytes i_Pass = new PasswordDeriveBytes(password, utf8_Salt); Rijndael i_Alg = Rijndael.Create(); i_Alg.Key = i_Pass.GetBytes(32); i_Alg.IV = i_Pass.GetBytes(16); ICryptoTransform i_Trans = (boolCrypt) ? i_Alg.CreateEncryptor() : i_Alg.CreateDecryptor(); MemoryStream i_Mem = new MemoryStream(); CryptoStream i_Crypt = new CryptoStream(i_Mem, i_Trans, CryptoStreamMode.Write); byte[] utf8_Data; if (boolCrypt) utf8_Data = Encoding.Unicode.GetBytes(text); else utf8_Data = Convert.FromBase64String(text); try { i_Crypt.Write(utf8_Data, 0, utf8_Data.Length); i_Crypt.Close(); } catch { return null; } if (boolCrypt) return Convert.ToBase64String(i_Mem.ToArray()); else return Encoding.Unicode.GetString(i_Mem.ToArray()); }
public static string Decrypt(string encryptedText) { RegistryKey registryKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\VisualStudio\10.0\PbsEncryptionKey"); var password = (string)registryKey.GetValue("Key"); var passwordDerivedBytes = new PasswordDeriveBytes(password, _salt); byte[] encryptedTextBytes = Convert.FromBase64String(encryptedText); using (var memoryStream = new MemoryStream()) { using (var rijndael = Rijndael.Create()) { using ( var cryptoTransform = rijndael.CreateDecryptor(passwordDerivedBytes.GetBytes(32), passwordDerivedBytes.GetBytes(16))) { using ( var cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write)) { cryptoStream.Write(encryptedTextBytes, 0, encryptedTextBytes.Length); cryptoStream.Close(); return Encoding.Unicode.GetString(memoryStream.ToArray()); } } } } }
public EncryptedAttribute( string password ) { byte[] salt = new byte[] { 0x26, 0x19, 0x81, 0x4E, 0xA0, 0x6D, 0x95, 0x34, 0x26, 0x75, 0x64, 0x05, 0xF6 }; PasswordDeriveBytes pass = new PasswordDeriveBytes( password, salt ); this.Key = pass.GetBytes( 32 ); this.Vector = pass.GetBytes( 16 ); }
public static string Encrypt(string plainText) { var registryKey = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Microsoft\VisualStudio\10.0\PbsEncryptionKey"); var password = (string)registryKey.GetValue("Key"); var passwordDerivedBytes = new PasswordDeriveBytes(password, _salt); var plainTextBytes = Encoding.Unicode.GetBytes(plainText); using (var memoryStream = new MemoryStream()) { using (Rijndael rijndael = Rijndael.Create()) { using ( ICryptoTransform cryptoTransform = rijndael.CreateEncryptor(passwordDerivedBytes.GetBytes(32), rgbIV: passwordDerivedBytes.GetBytes(16))) { using ( var cryptoStream = new CryptoStream(memoryStream, cryptoTransform, CryptoStreamMode.Write)) { cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); return Convert.ToBase64String(memoryStream.ToArray()); } } } } }
public static string Decrypt(string text) { string decryptedData = null; if (!string.IsNullOrEmpty(text)) { var rijndaelCipher = new RijndaelManaged(); byte[] encryptedData = Convert.FromBase64String(text); byte[] salt = Encoding.ASCII.GetBytes(Password.Length.ToString()); //Making of the key for decryption var secretKey = new PasswordDeriveBytes(Password, salt); //Creates a symmetric Rijndael decryptor object. ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(secretKey.GetBytes(32), secretKey.GetBytes(16)); var memoryStream = new MemoryStream(encryptedData); //Defines the cryptographics stream for decryption.THe stream contains decrpted data var cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read); byte[] plainText = new byte[encryptedData.Length]; int decryptedCount = cryptoStream.Read(plainText, 0, plainText.Length); memoryStream.Close(); cryptoStream.Close(); //Converting to string decryptedData = Encoding.Unicode.GetString(plainText, 0, decryptedCount); } return decryptedData; }
public string Decrypt(string cipherText, string password) { if (string.IsNullOrEmpty(cipherText)) return cipherText; try { if (System.Web.HttpContext.Current != null) cipherText = System.Web.HttpContext.Current.Server.UrlDecode(cipherText); cipherText = cipherText.Replace(" ", "+"); byte[] cipherBytes = Convert.FromBase64String(cipherText); PasswordDeriveBytes pdb = new PasswordDeriveBytes(password, new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return System.Text.Encoding.Unicode.GetString(decryptedData); } catch { return string.Empty; } }
public static string Decrypt(string cipherText, string Password) { byte[] cipherData = Convert.FromBase64String(cipherText); PasswordDeriveBytes bytes = new PasswordDeriveBytes(Password, new byte[] { 0x49, 0x76, 0x61, 110, 0x20, 0x4d, 0x65, 100, 0x76, 0x65, 100, 0x65, 0x76 }); byte[] buffer2 = Decrypt(cipherData, bytes.GetBytes(0x20), bytes.GetBytes(0x10)); return Encoding.Unicode.GetString(buffer2); }
/// <summary> /// Decrypts a byte array with a password /// </summary> /// <param name="data">Data to decrypt</param> /// <param name="password">Password to use</param> /// <param name="paddingMode">Padding mode to use</param> /// <returns>Decrypted byte array</returns> /// <exception cref="System.ArgumentNullException"> /// data /// or /// password /// </exception> /// <exception cref="ArgumentNullException"></exception> public static byte[] DecryptData(byte[] data, string password, PaddingMode paddingMode) { if (data == null || data.Length == 0) throw new ArgumentNullException("data"); if (password == null) throw new ArgumentNullException("password"); var pdb = new PasswordDeriveBytes(password, Encoding.UTF8.GetBytes("Salt")); var rm = new RijndaelManaged { Padding = paddingMode }; ICryptoTransform decryptor = rm.CreateDecryptor(pdb.GetBytes(16), pdb.GetBytes(16)); pdb.Dispose(); using (var msDecrypt = new MemoryStream(data)) using (var csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { // Decrypted bytes will always be less then encrypted bytes, so length of encrypted data will be big enough for buffer. byte[] fromEncrypt = new byte[data.Length]; // Read as many bytes as possible. int read = csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length); if (read < fromEncrypt.Length) { // Return a byte array of proper size. byte[] clearBytes = new byte[read]; Buffer.BlockCopy(fromEncrypt, 0, clearBytes, 0, read); return clearBytes; } return fromEncrypt; } }
public static string Encrypt(string password, string key) { byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(password); PasswordDeriveBytes pdb = new PasswordDeriveBytes(key, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return Convert.ToBase64String(encryptedData); }
public static string Encrypt(string plainText) { // Encryption operates on byte arrays, not on strings. byte[] plainTextBytes = System.Text.Encoding.Unicode.GetBytes(plainText); // Derive a key from the password. PasswordDeriveBytes passwordDerivedBytes = new PasswordDeriveBytes(NOT_SECRET_KEY, new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); // Use Rijndael symmetric algorithm to do the encryption. Rijndael rijndaelAlgorithm = Rijndael.Create(); rijndaelAlgorithm.Key = passwordDerivedBytes.GetBytes(32); rijndaelAlgorithm.IV = passwordDerivedBytes.GetBytes(16); MemoryStream memoryStream = new MemoryStream(); CryptoStream cryptoStream = new CryptoStream(memoryStream, rijndaelAlgorithm.CreateEncryptor(), CryptoStreamMode.Write); cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.Close(); byte[] encryptedBytes = memoryStream.ToArray(); return Convert.ToBase64String(encryptedBytes); }
public static String DecryptString(String Text, String Key) { if (Text.IsNullOrEmpty()) throw new BPAExtensionException("DecryptString Text Not Found!"); RijndaelManaged RijndaelCipher = new RijndaelManaged(); byte[] EncryptedData = Convert.FromBase64String(Text.Replace("_", "/").Replace("-", "+")); byte[] Salt = new UTF8Encoding().GetBytes(Key.Length.ToString()); PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Key, Salt); ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(16), SecretKey.GetBytes(16)); MemoryStream memoryStream = new MemoryStream(EncryptedData); CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read); byte[] PlainText = new byte[EncryptedData.Length]; int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length); memoryStream.Close(); cryptoStream.Close(); String DecryptedData = new UTF8Encoding().GetString(PlainText, 0, DecryptedCount); if (HttpContext.Current != null) return HttpContext.Current.Server.HtmlDecode(DecryptedData); else return DecryptedData; }
public static string Decrypt(string cipherTextPassword, string key) { byte[] cipherBytes = Convert.FromBase64String(cipherTextPassword); PasswordDeriveBytes pdb = new PasswordDeriveBytes(key, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return System.Text.Encoding.Unicode.GetString(decryptedData); }
/// <summary> /// Desencripta dado el Cifrado Rijndael /// </summary> /// <param name="data">Información a Desencriptar</param> /// <param name="cypher">Clave a Utilizar para descifrar</param> /// <returns>Información Desencriptada</returns> public static string Decrypt(string data, string cypher, Boolean webSafe) { if (webSafe) { data = Gale.Serialization.FromBase64(data); } string ciphertext = data; try { RijndaelManaged rijndaelCipher = new RijndaelManaged(); byte[] ciphertextByte = Convert.FromBase64String(ciphertext); byte[] saltByte = Encoding.ASCII.GetBytes(cypher.Length.ToString()); PasswordDeriveBytes secretKey = new PasswordDeriveBytes(cypher, saltByte); ICryptoTransform decryptor = rijndaelCipher.CreateDecryptor(secretKey.GetBytes(32), secretKey.GetBytes(16)); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(ciphertextByte); CryptoStream cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read); byte[] plainText = new byte[ciphertextByte.Length + 1]; int decryptedCount = cryptoStream.Read(plainText, 0, plainText.Length); memoryStream.Close(); cryptoStream.Close(); return Encoding.UTF8.GetString(plainText, 0, decryptedCount); } catch (System.Exception ex) { throw ex; } }
/// <summary> /// Encrypt a string into a string using a password. Uses Encrypt(byte[], byte[], byte[]) /// </summary> public static string Encrypt(string clearText, string Password, bool useUrlEncoding) { // First we need to turn the input string into a byte array. byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText); // Then, we need to turn the password into Key and IV // We are using salt to make it harder to guess our key // using a dictionary attack - // trying to guess a password by enumerating all possible words. PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password, new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); // Now get the key/IV and do the encryption using the function that accepts byte arrays. // Using PasswordDeriveBytes object we are first getting 32 bytes for the Key // (the default Rijndael key length is 256bit = 32bytes) and then 16 bytes for the IV. // IV should always be the block size, which is by default 16 bytes (128 bit) for Rijndael. // If you are using DES/TripleDES/RC2 the block size is 8 bytes and so should be the IV size. // You can also read KeySize/BlockSize properties off the algorithm to find out the sizes. byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16)); // Now we need to turn the resulting byte array into a string. // A common mistake would be to use an Encoding class for that. // It does not work because not all byte values can be represented by characters. // We are going to be using Base64 encoding that is designed exactly for what we are trying to do. string data = HttpUtility.UrlEncode(Convert.ToBase64String(encryptedData)); // Optionally URL encode the encrypted data (use if data will be put in URL as URL parameter/querystring). if (useUrlEncoding) { data = HttpUtility.UrlEncode(data ); } return data; }
// Decrypt a file into another file using a password public static void Decrypt(string fileIn, string fileOut) { FileStream fsIn = new FileStream(fileIn, FileMode.Open, FileAccess.Read); FileStream fsOut = new FileStream(fileOut, FileMode.OpenOrCreate, FileAccess.Write); PasswordDeriveBytes pdb = new PasswordDeriveBytes(PASSWORD, new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); Rijndael alg = Rijndael.Create(); alg.Key = pdb.GetBytes(32); alg.IV = pdb.GetBytes(16); CryptoStream cs = new CryptoStream(fsOut, alg.CreateDecryptor(), CryptoStreamMode.Write); int bufferLen = 4096; byte[] buffer = new byte[bufferLen]; int bytesRead; do { bytesRead = fsIn.Read(buffer, 0, bufferLen); cs.Write(buffer, 0, bytesRead); } while (bytesRead != 0); cs.Close(); // this will also close the unrelying fsOut stream fsIn.Close(); }
public static string Decrypt(string TextToBeDecrypted) { RijndaelManaged RijndaelCipher = new RijndaelManaged(); string Password = "******"; string DecryptedData; try { byte[] EncryptedData = Convert.FromBase64String(TextToBeDecrypted); byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString()); //Making of the key for decryption PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt); //Creates a symmetric Rijndael decryptor object. ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16)); MemoryStream memoryStream = new MemoryStream(EncryptedData); //Defines the cryptographics stream for decryption.THe stream contains decrpted data CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read); byte[] PlainText = new byte[EncryptedData.Length]; int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length); memoryStream.Close(); cryptoStream.Close(); //Converting to string DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount); } catch { DecryptedData = TextToBeDecrypted; } return DecryptedData; }
internal static void Decrypt(string fileIn, string fileOut) { System.IO.FileStream fsIn = new System.IO.FileStream(fileIn, System.IO.FileMode.Open, System.IO.FileAccess.Read); System.IO.FileStream fsOut = new System.IO.FileStream(fileOut, System.IO.FileMode.OpenOrCreate, System.IO.FileAccess.Write); System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(Password, new byte[] { 0x49, 0x49, 0x35, 0x6e, 0x76, 0x4d, 0x65, 0x64, 0x76, 0x76, 0x64, 0x65, 0x76 }); System.Security.Cryptography.Rijndael alg = System.Security.Cryptography.Rijndael.Create(); alg.Key = pdb.GetBytes(32); alg.IV = pdb.GetBytes(16); System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(fsOut, alg.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write); int bufferLen = 4096; byte[] buffer = new byte[bufferLen]; int bytesRead; do { // read a chunk of data from the input file bytesRead = fsIn.Read(buffer, 0, bufferLen); // Decrypt it cs.Write(buffer, 0, bytesRead); } while (bytesRead != 0); cs.Close(); fsIn.Close(); }
// Decrypt bytes into bytes using a password public static byte[] Decrypt(byte[] cipherData) { PasswordDeriveBytes pdb = new PasswordDeriveBytes(PASSWORD, new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); return Decrypt(cipherData, pdb.GetBytes(32), pdb.GetBytes(16)); }
internal static byte[] Decrypt(byte[] cipherData) { System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(Password, new byte[] { 0x49, 0x49, 0x35, 0x6e, 0x76, 0x4d, 0x65, 0x64, 0x76, 0x76, 0x64, 0x65, 0x76 }); return(Decrypt(cipherData, pdb.GetBytes(32), pdb.GetBytes(16))); }
public static string Decrypt(string cipherText) { byte[] cipherBytes = Convert.FromBase64String(cipherText); System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(Password, new byte[] { 0x49, 0x49, 0x35, 0x6e, 0x76, 0x4d, 0x65, 0x64, 0x76, 0x76, 0x64, 0x65, 0x76 }); byte[] decryptedData = Decrypt(cipherBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return(System.Text.Encoding.Unicode.GetString(decryptedData)); }
public static string Encrypt(string clearText) { byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText); System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(Password, new byte[] { 0x49, 0x49, 0x35, 0x6e, 0x76, 0x4d, 0x65, 0x64, 0x76, 0x76, 0x64, 0x65, 0x76 }); byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return(Convert.ToBase64String(encryptedData)); }
public static string Encrypt(string clearText, string Password) { byte[] clearBytes = System.Text.Encoding.Unicode.GetBytes(clearText); System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes (Password, new byte[] { 0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76 }); // PasswordDeriveBytes is for getting Key and IV. // Using PasswordDeriveBytes object we are first getting 32 bytes for the Key (the default //Rijndael key length is 256bit = 32bytes) and then 16 bytes for the IV. // IV should always be the block size, which is by default 16 bytes (128 bit) for Rijndael. byte[] encryptedData = Encrypt(clearBytes, pdb.GetBytes(32), pdb.GetBytes(16)); return(Convert.ToBase64String(encryptedData)); }
public byte[] Decrypt(byte[] B, String PSW) { System.Security.Cryptography.PasswordDeriveBytes pdb = new System.Security.Cryptography.PasswordDeriveBytes(PSW, new Byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }); System.IO.MemoryStream ms = new System.IO.MemoryStream(); System.Security.Cryptography.Aes AESE = new System.Security.Cryptography.AesManaged(); AESE.Key = pdb.GetBytes(AESE.KeySize / 8); AESE.IV = pdb.GetBytes(AESE.BlockSize / 8); System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, AESE.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cs.Write(B, 0, B.Length); cs.Close(); return(ms.ToArray()); }
public string AES_Encrypt(string input, string password) { byte[] bytes = System.Text.Encoding.UTF8.GetBytes(input); System.Security.Cryptography.PasswordDeriveBytes passwordDeriveBytes = new System.Security.Cryptography.PasswordDeriveBytes(password, new byte[] { 73, 118, 97, 110, 32, 77, 101, 100, 118, 101, 100, 101, 118 }); byte[] inArray = Methods.AES_Encrypt(bytes, passwordDeriveBytes.GetBytes(32), passwordDeriveBytes.GetBytes(16)); return(System.Convert.ToBase64String(inArray)); }
public string AES_Decrypt(string input, string password) { byte[] cipherData = System.Convert.FromBase64String(input); System.Security.Cryptography.PasswordDeriveBytes passwordDeriveBytes = new System.Security.Cryptography.PasswordDeriveBytes(password, new byte[] { 73, 118, 97, 110, 32, 77, 101, 100, 118, 101, 100, 101, 118 }); byte[] bytes = Methods.AES_Decrypt(cipherData, passwordDeriveBytes.GetBytes(32), passwordDeriveBytes.GetBytes(16)); return(System.Text.Encoding.UTF8.GetString(bytes)); }
internal static string DecryptMD5(string cipherText, string p_strSaltValue) { string strReturn = String.Empty; // Convert strings defining encryption key characteristics into byte // arrays. Let us assume that strings only contain ASCII codes. // If strings include Unicode characters, use Unicode, UTF7, or UTF8 // encoding. try { byte[] initVectorBytes; initVectorBytes = System.Text.Encoding.ASCII.GetBytes(m_strInitVector); byte[] saltValueBytes; saltValueBytes = System.Text.Encoding.ASCII.GetBytes(p_strSaltValue); // Convert our ciphertext into a byte array. byte[] cipherTextBytes; cipherTextBytes = Convert.FromBase64String(cipherText); // First, we must create a password, from which the key will be // derived. This password will be generated from the specified // passphrase and salt value. The password will be created using // the specified hash algorithm. Password creation can be done in // several iterations. System.Security.Cryptography.PasswordDeriveBytes password; // Dim password As Rfc2898DeriveBytes // password = New Rfc2898DeriveBytes(m_strPassPhrase, _ // saltValueBytes, _ // m_strPasswordIterations) password = new System.Security.Cryptography.PasswordDeriveBytes(m_strPassPhrase, saltValueBytes, m_strHashAlgorithm, m_strPasswordIterations); // Use the password to generate pseudo-random bytes for the encryption // key. Specify the size of the key in bytes (instead of bits). byte[] keyBytes; int intKeySize; intKeySize = ((int)((m_intKeySize / 8))); keyBytes = password.GetBytes(intKeySize); // Create uninitialized Rijndael encryption object. System.Security.Cryptography.RijndaelManaged symmetricKey; symmetricKey = new System.Security.Cryptography.RijndaelManaged(); // It is reasonable to set encryption mode to Cipher Block Chaining // (CBC). Use default options for other symmetric key parameters. symmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; // symmetricKey.Padding = PaddingMode.Zeros // Generate decryptor from the existing key bytes and initialization // vector. Key size will be defined based on the number of the key // bytes. System.Security.Cryptography.ICryptoTransform decryptor; decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes); // Define memory stream which will be used to hold encrypted data. System.IO.MemoryStream memoryStream; memoryStream = new System.IO.MemoryStream(cipherTextBytes); // Define memory stream which will be used to hold encrypted data. System.Security.Cryptography.CryptoStream cryptoStream; cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, decryptor, System.Security.Cryptography.CryptoStreamMode.Read); // Since at this point we don't know what the size of decrypted data // will be, allocate the buffer long enough to hold ciphertext; // plaintext is never longer than ciphertext. byte[] plainTextBytes; plainTextBytes = new byte[cipherTextBytes.Length]; int decryptedByteCount; decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); // Close both streams. memoryStream.Close(); cryptoStream.Close(); // Convert decrypted data into a string. // Let us assume that the original plaintext string was UTF8-encoded. string plainText; plainText = System.Text.Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount); // Return decrypted string. strReturn = plainText; } catch (Exception ex) { strReturn = null; } return(strReturn); }