public static string Criptografar(string texto) { if(string.IsNullOrEmpty(texto)) return String.Empty; string outStr; RijndaelManaged aesAlg = null; try { var key = new Rfc2898DeriveBytes(Segredo, Complemento); aesAlg = new RijndaelManaged(); aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8); aesAlg.IV = key.GetBytes(aesAlg.BlockSize / 8); var encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (var msEncrypt = new MemoryStream()) { using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (var swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(texto); } } outStr = Convert.ToBase64String(msEncrypt.ToArray()); } } finally { if (aesAlg != null) aesAlg.Clear(); } return outStr; }
public string Decrypt(string strEncryptedText) { if (strEncryptedText == null || strEncryptedText.Equals("")) return strEncryptedText; string strDecryptedText = null; RijndaelManaged rijndael = new RijndaelManaged(); ICryptoTransform decryptor = rijndael.CreateDecryptor(Key, IV); byte[] byteEncryptedText = Convert.FromBase64String(strEncryptedText); MemoryStream memStream = new MemoryStream(byteEncryptedText); CryptoStream decryptStream = null; try { decryptStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read); byte[] byteDecryptedText = new byte[byteEncryptedText.Length]; int decryptedByteCount = decryptStream.Read(byteDecryptedText, 0, byteDecryptedText.Length); strDecryptedText = Encoding.UTF8.GetString(byteDecryptedText, 0, decryptedByteCount); } finally { if (rijndael != null) rijndael.Clear(); if (decryptor != null) decryptor.Dispose(); if (memStream != null) memStream.Close(); if (decryptStream != null) decryptStream.Close(); } if (UseSalt) strDecryptedText = strDecryptedText.Substring(8); return strDecryptedText; }
public static string Descriptografar(string codigo) { try { if (string.IsNullOrEmpty(codigo)) return String.Empty; string retorno; var chave = new Rfc2898DeriveBytes(Segredo, Complemento); var algoritimo = new RijndaelManaged(); algoritimo.Key = chave.GetBytes(algoritimo.KeySize / 8); algoritimo.IV = chave.GetBytes(algoritimo.BlockSize / 8); var descriptografor = algoritimo.CreateDecryptor(algoritimo.Key, algoritimo.IV); var bytes = Convert.FromBase64String(codigo); using (var memoryStream = new MemoryStream(bytes)) using (var cryptoStream = new CryptoStream(memoryStream, descriptografor, CryptoStreamMode.Read)) using (var streamReader = new StreamReader(cryptoStream)) retorno = streamReader.ReadToEnd(); algoritimo.Clear(); return retorno; } catch (Exception) { return "DEU PAU"; } }
/// <summary> /// AES解密(无向量) /// </summary> /// <param name="encryptedBytes">被加密的明文</param> /// <param name="key">密钥</param> /// <returns>明文</returns> public static string AESDecryptWithoutVector(String Data, String Key) { Byte[] encryptedBytes = Convert.FromBase64String(Data); Byte[] bKey = new Byte[32]; Array.Copy(Encoding.UTF8.GetBytes(Key.PadRight(bKey.Length)), bKey, bKey.Length); MemoryStream mStream = new MemoryStream(encryptedBytes); //mStream.Write( encryptedBytes, 0, encryptedBytes.Length ); //mStream.Seek( 0, SeekOrigin.Begin ); RijndaelManaged aes = new RijndaelManaged(); aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; aes.KeySize = 128; aes.Key = bKey; //aes.IV = _iV; CryptoStream cryptoStream = new CryptoStream(mStream, aes.CreateDecryptor(), CryptoStreamMode.Read); try { byte[] tmp = new byte[encryptedBytes.Length + 32]; int len = cryptoStream.Read(tmp, 0, encryptedBytes.Length + 32); byte[] ret = new byte[len]; Array.Copy(tmp, 0, ret, 0, len); return Encoding.UTF8.GetString(ret); } finally { cryptoStream.Close(); mStream.Close(); aes.Clear(); } }
public static void DecryptFile(string inputFile, string outputFile, string skey) { RijndaelManaged aes = new RijndaelManaged(); try { byte[] key = ASCIIEncoding.UTF8.GetBytes(skey); using (FileStream fsCrypt = new FileStream(inputFile, FileMode.Open)) { using (FileStream fsOut = new FileStream(outputFile, FileMode.Create)) { using (CryptoStream cs = new CryptoStream(fsCrypt, aes.CreateDecryptor(key, key), CryptoStreamMode.Read)) { int data; while ((data = cs.ReadByte()) != -1) { fsOut.WriteByte((byte)data); } aes.Clear(); } } } } catch (Exception ex) { Console.WriteLine(ex.Message); aes.Clear(); } }
public static string DecryptData(string strData, string key) { if (string.IsNullOrEmpty(strData)) return ""; byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(_initVector); byte[] SaltValueBytes = Encoding.ASCII.GetBytes(_salt); byte[] CipherTextBytes = Convert.FromBase64String(strData); PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(key, SaltValueBytes, _hashAlgo, _passIter); byte[] KeyBytes = DerivedPassword.GetBytes(_keySize / 8); RijndaelManaged SymmetricKey = new RijndaelManaged(); SymmetricKey.Mode = CipherMode.CBC; byte[] PlainTextBytes = new byte[CipherTextBytes.Length]; int ByteCount = 0; using (ICryptoTransform Decryptor = SymmetricKey.CreateDecryptor(KeyBytes, InitialVectorBytes)) { using (MemoryStream MemStream = new MemoryStream(CipherTextBytes)) { using (CryptoStream CryptoStream = new CryptoStream(MemStream, Decryptor, CryptoStreamMode.Read)) { ByteCount = CryptoStream.Read(PlainTextBytes, 0, PlainTextBytes.Length); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return Encoding.UTF8.GetString(PlainTextBytes, 0, ByteCount); }
public static string Decrypt(this byte[] data, byte[] key) { if (data == null) throw new ArgumentNullException("data"); if (key == null || key.Length != 32) throw new ArgumentException("Key must have 32 length", "key"); string result; using (var c = new RijndaelManaged()) { c.Key = key; using (var ms = new MemoryStream()) { int ReadPos = 0; byte[] IV = new byte[c.IV.Length]; Array.Copy(data, IV, IV.Length); c.IV = IV; ReadPos += c.IV.Length; using (var cs = new CryptoStream(ms, c.CreateDecryptor(), CryptoStreamMode.Write)) { cs.Write(data, ReadPos, data.Length - ReadPos); cs.FlushFinalBlock(); } result = Encoding.Unicode.GetString(ms.ToArray()); } c.Clear(); } return result; }
public bool decriptarAES(out string decriptedData) { try { RijndaelManaged aesAlg = new RijndaelManaged(); aesAlg.Key = _key; aesAlg.IV = _initializatorVector; ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); MemoryStream msDecrypt = new MemoryStream(_cipherText); CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read); StreamReader srDecrypt = new StreamReader(csDecrypt); decriptedData = srDecrypt.ReadToEnd(); srDecrypt.Close(); csDecrypt.Close(); msDecrypt.Close(); aesAlg.Clear(); return true; } catch { decriptedData = null; return false; } }
/// <summary> /// Decrypt input encryptedBytes /// </summary> /// <param name="encryptedBytes">Encrypted byte array</param> /// <param name="Key">Secret key</param> /// <param name="IV">Initialize vector</param> /// <returns>Decrypt text</returns> public static string RijndaelDecrypt(byte[] encryptedBytes, byte[] Key, byte[] IV) { RijndaelManaged aesAlg = null; string plaintext = null; try { aesAlg = new RijndaelManaged(); aesAlg.Key = Key; aesAlg.IV = IV; ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msDecrypt = new MemoryStream(encryptedBytes)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader srDecrypt = new StreamReader(csDecrypt)) plaintext = srDecrypt.ReadToEnd(); } } } finally { if (aesAlg != null) aesAlg.Clear(); } return plaintext; }
/// <summary> /// Encrypts a string /// </summary> /// <param name="PlainText">Text to be encrypted</param> /// <param name="Password">Password to encrypt with</param> /// <param name="Salt">Salt to encrypt with</param> /// <param name="HashAlgorithm">Can be either SHA1 or MD5</param> /// <param name="PasswordIterations">Number of iterations to do</param> /// <param name="InitialVector">Needs to be 16 ASCII characters long</param> /// <param name="KeySize">Can be 128, 192, or 256</param> /// <returns>An encrypted string</returns> public static string Encrypt(string PlainText, string Password, string Salt = "Kosher", string HashAlgorithm = "SHA1", int PasswordIterations = 2, string InitialVector = "OFRna73m*aze01xY", int KeySize = 256) { if (string.IsNullOrEmpty(PlainText)) return ""; byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector); byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt); byte[] PlainTextBytes = Encoding.UTF8.GetBytes(PlainText); PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations); byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8); RijndaelManaged SymmetricKey = new RijndaelManaged(); SymmetricKey.Mode = CipherMode.CBC; byte[] CipherTextBytes = null; using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes)) { using (MemoryStream MemStream = new MemoryStream()) { using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write)) { CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length); CryptoStream.FlushFinalBlock(); CipherTextBytes = MemStream.ToArray(); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return Convert.ToBase64String(CipherTextBytes); }
/// <summary> /// Decrypts a string /// </summary> /// <param name="cipherText">Text to be decrypted</param> /// <param name="password">Password to decrypt with</param> /// <param name="salt">Salt to decrypt with</param> /// <param name="hashAlgorithm">Can be either SHA1 or MD5</param> /// <param name="passwordIterations">Number of iterations to do. The number of times the algorithm is run on the text. </param> /// <param name="initialVector">Needs to be 16 ASCII characters long</param> /// <param name="keySize">Can be 128, 192, or 256</param> /// <returns>A decrypted string</returns> public static string Decrypt(string cipherText, string password, string salt = "69ad1bfbd6605f3f6a3011460cdfb9db7757e0f9", string hashAlgorithm = "SHA1", int passwordIterations = 2, string initialVector = "OFRna73m*aze01xY", int keySize = 256) { if (string.IsNullOrEmpty(cipherText)) return ""; byte[] initialVectorBytes = Encoding.ASCII.GetBytes(initialVector); byte[] saltValueBytes = Encoding.ASCII.GetBytes(salt); byte[] cipherTextBytes = Convert.FromBase64String(cipherText); var derivedPassword = new PasswordDeriveBytes(password, saltValueBytes, hashAlgorithm, passwordIterations); byte[] keyBytes = derivedPassword.GetBytes(keySize / 8); var symmetricKey = new RijndaelManaged {Mode = CipherMode.CBC}; byte[] plainTextBytes = new byte[cipherTextBytes.Length]; int byteCount; using (ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initialVectorBytes)) { using (MemoryStream memStream = new MemoryStream(cipherTextBytes)) { using (CryptoStream cryptoStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read)) { byteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); memStream.Close(); cryptoStream.Close(); } } } symmetricKey.Clear(); return Encoding.UTF8.GetString(plainTextBytes, 0, byteCount); }
public static string AESDecrypt(string decryptString, string key) { byte[] inputData = new byte[decryptString.Length / 2]; Convert.FromBase64String(decryptString); int arrayIndex = 0; foreach (byte b in inputData) { inputData[arrayIndex] = (byte)Convert.ToInt32(decryptString.Substring(arrayIndex * 2, 2), 16); arrayIndex = arrayIndex + 1; } RijndaelManaged rijndaelManager = new RijndaelManaged(); rijndaelManager.Key = Encoding.UTF8.GetBytes(key.PadRight(32, ' ').Substring(0, 32)); rijndaelManager.IV = AESIV; rijndaelManager.Mode = CipherMode.CBC; rijndaelManager.Padding = PaddingMode.PKCS7; ICryptoTransform rijndaelDecryptor = rijndaelManager.CreateDecryptor(); try { byte[] decryptedData = rijndaelDecryptor.TransformFinalBlock(inputData, 0, inputData.Length); return Encoding.UTF8.GetString(decryptedData); } catch { return string.Empty; } finally { rijndaelDecryptor.Dispose(); rijndaelManager.Clear(); } }
public static String read(byte[] cypher, string KeyString, string IVString) { var sRet = ""; var encoding = new UTF8Encoding(); var Key = encoding.GetBytes(KeyString); var IV = encoding.GetBytes(IVString); using (var rj = new RijndaelManaged()) { try { rj.Padding = PaddingMode.PKCS7; rj.Mode = CipherMode.CBC; rj.KeySize = 256; rj.BlockSize = 256; rj.Key = Key; rj.IV = IV; var ms = new MemoryStream(cypher); using (var cs = new CryptoStream(ms, rj.CreateDecryptor(Key, IV), CryptoStreamMode.Read)) { using (var sr = new StreamReader(cs)) { sRet = sr.ReadLine(); } } } finally { rj.Clear(); } } return sRet; }
public static string DecryptData(string strData, string key) { if (string.IsNullOrEmpty(strData)) return ""; byte[] initialVectorBytes = Encoding.ASCII.GetBytes(InitVector); byte[] saltValueBytes = Encoding.ASCII.GetBytes(Salt); byte[] cipherTextBytes = Convert.FromBase64String(strData); var derivedPassword = new PasswordDeriveBytes(key, saltValueBytes, HashAlgo, PassIter); #pragma warning disable 612,618 byte[] keyBytes = derivedPassword.GetBytes(KeySize/8); #pragma warning restore 612,618 var symmetricKey = new RijndaelManaged {Mode = CipherMode.CBC}; var plainTextBytes = new byte[cipherTextBytes.Length]; int byteCount; using (ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initialVectorBytes)) { using (var memStream = new MemoryStream(cipherTextBytes)) { using (var cryptoStream = new CryptoStream(memStream, decryptor, CryptoStreamMode.Read)) { byteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); memStream.Close(); cryptoStream.Close(); } } } symmetricKey.Clear(); return Encoding.UTF8.GetString(plainTextBytes, 0, byteCount); }
static void Main(string[] args) { byte[] bytes = System.Text.Encoding.Unicode.GetBytes(args[0]); System.Security.Cryptography.RijndaelManaged rijndaelManaged = new System.Security.Cryptography.RijndaelManaged(); rijndaelManaged.Key = bytes; XmlDocument xmlDocument = new XmlDocument(); xmlDocument.PreserveWhitespace = true; xmlDocument.Load("needfiles"); XmlElement xmlElement = xmlDocument.GetElementsByTagName("EncryptedData")[0] as XmlElement; EncryptedData encryptedData = new EncryptedData(); encryptedData.LoadXml(xmlElement); EncryptedXml encryptedXml = new EncryptedXml(); byte[] decryptedData = encryptedXml.DecryptData(encryptedData, rijndaelManaged); encryptedXml.ReplaceData(xmlElement, decryptedData); if (rijndaelManaged != null) { rijndaelManaged.Clear(); } Console.WriteLine(xmlDocument.OuterXml); }
public static string EncryptData(string strData, string key) { if (string.IsNullOrEmpty(strData)) return ""; byte[] initialVectorBytes = Encoding.ASCII.GetBytes(InitVector); byte[] saltValueBytes = Encoding.ASCII.GetBytes(Salt); byte[] plainTextBytes = Encoding.UTF8.GetBytes(strData); var derivedPassword = new PasswordDeriveBytes(key, saltValueBytes, HashAlgo, PassIter); #pragma warning disable 612,618 byte[] keyBytes = derivedPassword.GetBytes(KeySize/8); #pragma warning restore 612,618 var symmetricKey = new RijndaelManaged {Mode = CipherMode.CBC}; byte[] cipherTextBytes; using (ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initialVectorBytes)) { using (var memStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write)) { cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); cipherTextBytes = memStream.ToArray(); memStream.Close(); cryptoStream.Close(); } } } symmetricKey.Clear(); return Convert.ToBase64String(cipherTextBytes); }
/// <summary> /// Encrypts a string /// </summary> /// <param name="plainText">Text to be encrypted</param> /// <param name="password">Password to encrypt with</param> /// <param name="salt">Salt to encrypt with</param> /// <param name="passwordIterations">Number of iterations to do</param> /// <param name="initialVector">Needs to be 16 ASCII characters long</param> /// <param name="keySize">Can be 128, 192, or 256</param> /// <returns>An encrypted string</returns> public static string Encrypt(string plainText, string password, string salt, int passwordIterations = 1000, string initialVector = "OFRna73m*aze01xY", int keySize = 256) { if (string.IsNullOrEmpty(plainText)) return ""; var initialVectorBytes = Encoding.ASCII.GetBytes(initialVector); var saltValueBytes = Encoding.ASCII.GetBytes(salt); var plainTextBytes = Encoding.UTF8.GetBytes(plainText); var derivedPassword = new Rfc2898DeriveBytes(password, saltValueBytes, passwordIterations); var keyBytes = derivedPassword.GetBytes(keySize / 8); var symmetricKey = new RijndaelManaged {Mode = CipherMode.CBC}; byte[] cipherTextBytes = null; using (var encryptor = symmetricKey.CreateEncryptor(keyBytes, initialVectorBytes)) { using (var memStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write)) { cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); cipherTextBytes = memStream.ToArray(); memStream.Close(); cryptoStream.Close(); } } } symmetricKey.Clear(); return Convert.ToBase64String(cipherTextBytes); }
public static string EncryptData(string strData, string key) { if (string.IsNullOrEmpty(strData)) return ""; byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(_initVector); byte[] SaltValueBytes = Encoding.ASCII.GetBytes(_salt); byte[] PlainTextBytes = Encoding.UTF8.GetBytes(strData); PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(key, SaltValueBytes, _hashAlgo, _passIter); byte[] KeyBytes = DerivedPassword.GetBytes(_keySize / 8); RijndaelManaged SymmetricKey = new RijndaelManaged(); SymmetricKey.Mode = CipherMode.CBC; byte[] CipherTextBytes = null; using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes)) { using (MemoryStream MemStream = new MemoryStream()) { using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write)) { CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length); CryptoStream.FlushFinalBlock(); CipherTextBytes = MemStream.ToArray(); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return Convert.ToBase64String(CipherTextBytes); }
/// <summary> /// Decrypts input string from Rijndael (AES) algorithm with CBC blocking and PKCS7 padding. /// </summary> /// <param name="inputBytes">Encrypted binary array to decrypt</param> /// <param name="password"></param> /// <returns>string of Decrypted data</returns> /// <remarks>The key and IV are the same, and use strEncryptionPassword.</remarks> private static string AesDecrypt(byte[] inputBytes, string password) { var AES = new RijndaelManaged { Padding = PaddingMode.PKCS7, Mode = CipherMode.CBC, KeySize = 128, BlockSize = 128 }; byte[] keyAndIvBytes = Encoding.UTF8.GetBytes(password); //create streams and decryptor object try { using (var memoryStream = new MemoryStream(inputBytes)) { using ( var cryptoStream = new CryptoStream(memoryStream, AES.CreateDecryptor(keyAndIvBytes, keyAndIvBytes), CryptoStreamMode.Read)) { var outputBytes = new byte[inputBytes.Length + 1]; cryptoStream.Read(outputBytes, 0, outputBytes.Length); return Encoding.UTF8.GetString(outputBytes); } } } finally { AES.Clear(); } }
public static string AESDecryptBase64(string decryptString, string key) { byte[] inputData = Convert.FromBase64String(decryptString); RijndaelManaged rijndaelManager = new RijndaelManaged(); rijndaelManager.Key = Encoding.UTF8.GetBytes(key.PadRight(32, ' ').Substring(0, 32)); rijndaelManager.IV = AESIV; rijndaelManager.Mode = CipherMode.CBC; rijndaelManager.Padding = PaddingMode.PKCS7; ICryptoTransform rijndaelDecryptor = rijndaelManager.CreateDecryptor(); try { byte[] decryptedData = rijndaelDecryptor.TransformFinalBlock(inputData, 0, inputData.Length); return Encoding.UTF8.GetString(decryptedData); } catch { return string.Empty; } finally { rijndaelDecryptor.Dispose(); rijndaelManager.Clear(); } }
private static object ReadObjectFromXml(string path) { try { object ob; using (Stream fs = new FileStream(path, FileMode.Open)) { var rm = new RijndaelManaged(); rm.BlockSize = rm.KeySize; var secretKey = new PasswordDeriveBytes(Encoding.Unicode.GetBytes(Salt), Encoding.ASCII.GetBytes(Salt)); // ReSharper disable once CSharpWarnings::CS0618 rm.Key = secretKey.GetBytes(rm.KeySize/8); rm.IV = rm.Key; var desEncrypt = rm.CreateDecryptor(); using (var cs = new CryptoStream(fs, desEncrypt, CryptoStreamMode.Read)) { var xmlser = new XmlSerializer(typeof (Data)); ob = xmlser.Deserialize(cs); } rm.Clear(); desEncrypt.Dispose(); } return ob; } catch (Exception ex) { Logger.Write(ex.Message); return null; } }
public static byte[] Decrypt(byte[] cipherBytes) { RijndaelManaged Crypto = null; MemoryStream ms = null; ICryptoTransform Decryptor = null; CryptoStream cryptoStream = null; Byte[] plainTextBytes = new byte[cipherBytes.Length]; using (Crypto = new RijndaelManaged()) { Crypto.Key = aesKey; Crypto.IV = aesIV; ms = new MemoryStream(cipherBytes); Decryptor = Crypto.CreateDecryptor(Crypto.Key, Crypto.IV); cryptoStream = new CryptoStream(ms, Decryptor, CryptoStreamMode.Read); cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); if (Crypto != null) Crypto.Clear(); ms.Flush(); ms.Close(); } int i = plainTextBytes.Length - 1; while (plainTextBytes[i] == 0) --i; byte[] finalResule = new byte[i + 1]; Array.Copy(plainTextBytes, finalResule, i + 1); return finalResule; }
/// <summary> /// AES加密 /// </summary> /// <param name="plainText">要加密的字串</param> /// <returns>加密后的字串</returns> public static string EncryptStringAES(string plainText) { if (string.IsNullOrEmpty(plainText)) throw new ArgumentNullException("plainText"); string outStr = null; RijndaelManaged aesAlg = null; try { Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(_secret, _salt); aesAlg = new RijndaelManaged(); aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8); ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int)); msEncrypt.Write(aesAlg.IV, 0, aesAlg.IV.Length); using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(plainText); } } outStr = Convert.ToBase64String(msEncrypt.ToArray()); } } finally { if (aesAlg != null) aesAlg.Clear(); } return outStr; }
public static byte[] Encrypt(byte[] data, byte[] key) { RijndaelManaged rijndaelManaged = new RijndaelManaged(); rijndaelManaged.Mode = CipherMode.CBC; rijndaelManaged.Padding = PaddingMode.PKCS7; rijndaelManaged.KeySize = 256; rijndaelManaged.BlockSize = 256; rijndaelManaged.Key = key; rijndaelManaged.IV = key; ICryptoTransform Encryptor = rijndaelManaged.CreateEncryptor(rijndaelManaged.Key, rijndaelManaged.IV); MemoryStream MemStream = new MemoryStream(); CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write); CryptoStream.Write(data, 0, data.Length); CryptoStream.FlushFinalBlock(); byte[] returnValue = MemStream.ToArray(); MemStream.Close(); CryptoStream.Close(); rijndaelManaged.Clear(); return returnValue; }
/// <summary> /// Encrypts a string /// </summary> /// <param name="PlainText">Text to be encrypted</param> /// <param name="Password">Password to encrypt with</param> /// <param name="Salt">Salt to encrypt with</param> /// <param name="InitialVector">Needs to be 16 ASCII characters long</param> /// <param name="HashAlgorithm">Can be either SHA1 or MD5</param> /// <param name="PasswordIterations">Number of iterations to do</param> /// <param name="KeySize">Can be 128, 192, or 256</param> /// <returns>An encrypted bytes</returns> public static byte[] Encrypt(byte[] PlainText, byte[] Password, byte[] InitialVector, byte[] Salt) { PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Password, Salt, HASH_ALGORITHM, PASSWORDITERATIONS); byte[] KeyBytes = DerivedPassword.GetBytes(KEY_SIZE / 8); RijndaelManaged SymmetricKey = new RijndaelManaged(); SymmetricKey.Mode = CipherMode.CBC; byte[] CipherTextBytes = null; using (ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVector)) { using (MemoryStream MemStream = new MemoryStream()) { using (CryptoStream CryptoStream = new CryptoStream(MemStream, Encryptor, CryptoStreamMode.Write)) { CryptoStream.Write(PlainText, 0, PlainText.Length); CryptoStream.FlushFinalBlock(); CipherTextBytes = MemStream.ToArray(); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return CipherTextBytes; //return Encoding.UTF8.GetBytes(Convert.ToBase64String(CipherTextBytes)); }
public static string Encrypt(string toEncrypt, string key) { string result = string.Empty; if (string.IsNullOrEmpty(toEncrypt)) { return result; } try { byte[] keyArray = ToByte(key); byte[] toEncryptArray = Encoding.Default.GetBytes(toEncrypt); RijndaelManaged rDel = new RijndaelManaged(); rDel.Key = keyArray; rDel.Mode = CipherMode.ECB; rDel.Padding = PaddingMode.PKCS7; ICryptoTransform cTransform = rDel.CreateEncryptor(); byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); rDel.Clear(); result = ToText(resultArray); } catch { } return result; }
public static string Decrypt(string cipher) { if (string.IsNullOrEmpty(cipher)) throw new ArgumentNullException("cipher"); RijndaelManaged alg = null; string plaintext = null; try { Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(shared, _salt); byte[] bytes = Convert.FromBase64String(cipher); using (MemoryStream msDecrypt = new MemoryStream(bytes)) { alg = new RijndaelManaged(); alg.Key = key.GetBytes(alg.KeySize / 8); alg.IV = ReadByteArray(msDecrypt); ICryptoTransform decryptor = alg.CreateDecryptor(alg.Key, alg.IV); using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader srDecrypt = new StreamReader(csDecrypt)) { plaintext = srDecrypt.ReadToEnd(); } } } } finally { if (alg != null) alg.Clear(); } return plaintext; }
public static string DecryptString(string data, byte[] key) { RijndaelManaged aesAlg = new RijndaelManaged(); try { byte[] bytes = Convert.FromBase64String(data); Rfc2898DeriveBytes pwddb = new Rfc2898DeriveBytes(key, _salt, 1); aesAlg.Key = pwddb.GetBytes(aesAlg.KeySize / 8); using (MemoryStream ms = new MemoryStream(bytes)) { aesAlg.IV = ReadByteArray(ms); ICryptoTransform dec = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV); using (CryptoStream cs = new CryptoStream(ms, dec, CryptoStreamMode.Read)) { using (StreamReader sr = new StreamReader(cs)) { return sr.ReadToEnd(); } } } } catch { return string.Empty; } finally { aesAlg.Clear(); } }
public String DecryptIt(String s, byte[] key = null, byte[] IV = null, PaddingMode padding = PaddingMode.PKCS7) { String result; //magically assign key and IV if one isn't given as an argument key = key ?? cryptKey; IV = IV ?? cryptIV; RijndaelManaged rijn = new RijndaelManaged(); rijn.Mode = CipherMode.CBC; rijn.Padding = padding; rijn.BlockSize = 256; using (MemoryStream msDecrypt = new MemoryStream(Convert.FromBase64String(s))) { using (ICryptoTransform decryptor = rijn.CreateDecryptor(key, IV)) { using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) { using (StreamReader swDecrypt = new StreamReader(csDecrypt)) { result = swDecrypt.ReadToEnd(); } } } } rijn.Clear(); return result; }
/// <summary> /// Decrypts a string /// </summary> /// <param name="CipherText">Text to be decrypted</param> /// <param name="Password">Password to decrypt with</param> /// <param name="Salt">Salt to decrypt with</param> /// <param name="HashAlgorithm">Can be either SHA1 or MD5</param> /// <param name="PasswordIterations">Number of iterations to do</param> /// <param name="InitialVector">Needs to be 16 ASCII characters long</param> /// <param name="KeySize">Can be 128, 192, or 256</param> /// <returns>A decrypted string</returns> public static string Decrypt(string CipherText, string Password, string Salt = "Kosher", string HashAlgorithm = "SHA1", int PasswordIterations = 2, string InitialVector = "OFRna73m*aze01xY", int KeySize = 256) { if (string.IsNullOrEmpty(CipherText)) return ""; byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector); byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt); byte[] CipherTextBytes = Convert.FromBase64String(CipherText); PasswordDeriveBytes DerivedPassword = new PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations); byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8); RijndaelManaged SymmetricKey = new RijndaelManaged(); SymmetricKey.Mode = CipherMode.CBC; byte[] PlainTextBytes = new byte[CipherTextBytes.Length]; int ByteCount = 0; using (ICryptoTransform Decryptor = SymmetricKey.CreateDecryptor(KeyBytes, InitialVectorBytes)) { using (MemoryStream MemStream = new MemoryStream(CipherTextBytes)) { using (CryptoStream CryptoStream = new CryptoStream(MemStream, Decryptor, CryptoStreamMode.Read)) { ByteCount = CryptoStream.Read(PlainTextBytes, 0, PlainTextBytes.Length); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return Encoding.UTF8.GetString(PlainTextBytes, 0, ByteCount); }
private static string decrypt_function(byte[] Cipher_Text, byte[] Key, byte[] IV) { RijndaelManaged Crypto = null; MemoryStream MemStream = null; ICryptoTransform Decryptor = null; CryptoStream Crypto_Stream = null; StreamReader Stream_Read = null; string Plain_Text; try { Crypto = new RijndaelManaged (); Crypto.Key = Key; Crypto.IV = IV; MemStream = new MemoryStream (Cipher_Text); //Create Decryptor make sure if you are decrypting that this is here and you did not copy paste encryptor. Decryptor = Crypto.CreateDecryptor (Crypto.Key, Crypto.IV); //This is different from the encryption look at the mode make sure you are reading from the stream. Crypto_Stream = new CryptoStream (MemStream, Decryptor, CryptoStreamMode.Read); //I used the stream reader here because the ReadToEnd method is easy and because it return a string, also easy. Stream_Read = new StreamReader (Crypto_Stream); Plain_Text = Stream_Read.ReadToEnd (); } finally { if (Crypto != null) Crypto.Clear (); MemStream.Flush (); MemStream.Close (); } return Plain_Text; }
public static void ValueWriteToFile() { string filename = "needfiles_xxx"; XmlWriterSettings xmlWriterSettings = new XmlWriterSettings(); xmlWriterSettings.CheckCharacters = false; xmlWriterSettings.ConformanceLevel = ConformanceLevel.Auto; xmlWriterSettings.OmitXmlDeclaration = false; System.IO.StringWriter stringWriter = new System.IO.StringWriter(); XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSettings); xmlWriter.WriteStartDocument(true); xmlWriter.WriteStartElement("Limit"); xmlWriter.WriteStartElement("DisLimit"); xmlWriter.WriteElementString("OnOff", "aaaaaaaa"); xmlWriter.WriteElementString("Radius", "bbbbbbbbbb"); xmlWriter.WriteEndElement(); int num = 0; System.Collections.ArrayList myAreaLimitList = new System.Collections.ArrayList(); foreach (string areaLimitClass in myAreaLimitList) // We are not actually writing ANY limits in this case... feel free to define the class and fix it. { xmlWriter.WriteStartElement("AreaLimit"); xmlWriter.WriteAttributeString("id", "ccccccc"); xmlWriter.WriteElementString("OnOff", "ddddddddddd"); xmlWriter.WriteElementString("Long", "eeeeeeeeeee"); xmlWriter.WriteElementString("Lati", "ffffffffffff"); xmlWriter.WriteElementString("Radius", "ggggggggggg"); xmlWriter.WriteEndElement(); num++; } xmlWriter.WriteEndElement(); xmlWriter.WriteEndDocument(); xmlWriter.Flush(); xmlWriter.Close(); string xml = stringWriter.ToString(); stringWriter.Close(); XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(xml); System.Security.Cryptography.RijndaelManaged rijndaelManaged = new System.Security.Cryptography.RijndaelManaged(); byte[] bytes = System.Text.Encoding.Unicode.GetBytes(args[0]); rijndaelManaged.Key = bytes; xmlDocument.PreserveWhitespace = true; Encrypt(xmlDocument, "Limit", rijndaelManaged); if (rijndaelManaged != null) { rijndaelManaged.Clear(); } xmlDocument.Save(filename); }