public static string decryptRJ256(string target, string key, string iv) { var rijndael = new System.Security.Cryptography.RijndaelManaged() { Padding = System.Security.Cryptography.PaddingMode.Zeros, Mode = System.Security.Cryptography.CipherMode.CBC, KeySize = 256, BlockSize = 256 }; var keyBytes = Encoding.ASCII.GetBytes(key); var ivBytes = Encoding.ASCII.GetBytes(iv); var decryptor = rijndael.CreateDecryptor(keyBytes, ivBytes); var toDecrypt = Convert.FromBase64String(target); var fromEncrypt = new byte[toDecrypt.Length]; var msDecrypt = new System.IO.MemoryStream(toDecrypt); var csDecrypt = new System.Security.Cryptography.CryptoStream(msDecrypt, decryptor, System.Security.Cryptography.CryptoStreamMode.Read); csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length); string data = Encoding.ASCII.GetString(fromEncrypt); data = data.Replace("\0", ""); return(data); }
private byte[] Encrypt(byte[] PlainData) { byte[] Result = null; try { System.Security.Cryptography.RijndaelManaged Enc = new System.Security.Cryptography.RijndaelManaged(); Enc.KeySize = 256; Enc.Key = this.Encryption_Key(); Enc.IV = this.Encryption_IV(); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); System.Security.Cryptography.CryptoStream cryptoStream = null; cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, Enc.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cryptoStream.Write(PlainData, 0, PlainData.Length); cryptoStream.FlushFinalBlock(); Result = memoryStream.ToArray(); cryptoStream.Close(); memoryStream.Close(); cryptoStream.Dispose(); memoryStream.Dispose(); } catch (Exception) { Result = null; } return(Result); }
/// <summary> /// 通过公钥做key进行加密,AES算法 /// </summary> /// <param name="text"></param> /// <returns></returns> private string EncryptByPublicKey(string text) { if (string.IsNullOrEmpty(text)) { return(null); } var content = File.ReadAllText(PublicKeySavePath.Replace("~", CallContext_Parameter.ServerRootPath)); var key = ComFunc.getMD5_String(ComFunc.Base64Code(content)); Byte[] toEncryptArray = Encoding.UTF8.GetBytes(text); System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged { Key = Encoding.UTF8.GetBytes(key), Mode = System.Security.Cryptography.CipherMode.ECB, Padding = System.Security.Cryptography.PaddingMode.PKCS7 }; System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateEncryptor(); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Convert.ToBase64String(resultArray, 0, resultArray.Length)); }
public static string encryptRJ256(string target, string key, string iv) { var rijndael = new System.Security.Cryptography.RijndaelManaged() { Padding = System.Security.Cryptography.PaddingMode.Zeros, Mode = System.Security.Cryptography.CipherMode.CBC, KeySize = 256, BlockSize = 256 }; var bytesKey = Encoding.ASCII.GetBytes(key); var bytesIv = Encoding.ASCII.GetBytes(iv); var encryptor = rijndael.CreateEncryptor(bytesKey, bytesIv); var msEncrypt = new System.IO.MemoryStream(); var csEncrypt = new System.Security.Cryptography.CryptoStream(msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write); var toEncrypt = Encoding.ASCII.GetBytes(target); csEncrypt.Write(toEncrypt, 0, toEncrypt.Length); csEncrypt.FlushFinalBlock(); var encrypted = msEncrypt.ToArray(); return(Convert.ToBase64String(encrypted)); }
private void init() { this.mode = new SicBlockCipher(new AesFastEngine()); // si las claves de encriptación no han sido inicializadas, las calculamos y las almacenamos en los valores estáticos. if (ClavesTokenizador.EncriptIV == null) { byte[] _salt = Encoding.UTF8.GetBytes(ConfigurationManager.AppSettings["Seguridad.Sal"]); System.Security.Cryptography.RijndaelManaged aesAlg = null; try { // Calculamos los valores de las claves de encriptación para ser usadas en el algoritmo System.Security.Cryptography.Rfc2898DeriveBytes key = new System.Security.Cryptography.Rfc2898DeriveBytes(ConfigurationManager.AppSettings["Seguridad.Secreto"], _salt); aesAlg = new System.Security.Cryptography.RijndaelManaged(); this.key = key.GetBytes(aesAlg.KeySize / 8); this.iv = key.GetBytes(aesAlg.BlockSize / 8); // Asignamos las variables de claves de ecnriptación a memoria ClavesTokenizador.EncriptKey = this.key; ClavesTokenizador.EncriptKey = this.iv; } catch { }; } else { // Obtenemos las variables de las claves del tokenizador de memoria this.key = ClavesTokenizador.EncriptKey; this.iv = ClavesTokenizador.EncriptIV; } }
/// <summary> /// 文字列を復号化 /// </summary> /// <param name="sourceString">暗号化文字列</param> /// <param name="password">パスワード</param> /// <returns>復号化後文字列</returns> public string DecryptString(string sourceString, string password) { byte[] key, iv, strBytes, decBytes; System.Security.Cryptography.RijndaelManaged rijndael; System.Security.Cryptography.ICryptoTransform decryptor; // 複合化(コンバートあり) try { // v2.0 rijndael = new System.Security.Cryptography.RijndaelManaged(); GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv, 100); rijndael.Key = key; rijndael.IV = iv; strBytes = System.Convert.FromBase64String(sourceString); decryptor = rijndael.CreateDecryptor(); decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); decryptor.Dispose(); } catch (Exception) { try { // v1.0-1.3 rijndael = new System.Security.Cryptography.RijndaelManaged(); GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv, 1000); rijndael.Key = key; rijndael.IV = iv; strBytes = System.Convert.FromBase64String(sourceString); decryptor = rijndael.CreateDecryptor(); decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); decryptor.Dispose(); } catch (Exception) { throw; } } return(System.Text.Encoding.UTF8.GetString(decBytes)); }
public static string AesDecrypt(string str, string key) { if (string.IsNullOrEmpty(str)) { return(null); } try { Byte[] toEncryptArray = Convert.FromBase64String(str); System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged { Key = Encoding.UTF8.GetBytes(key), Mode = System.Security.Cryptography.CipherMode.ECB, Padding = System.Security.Cryptography.PaddingMode.PKCS7 }; System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor(); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Encoding.UTF8.GetString(resultArray)); } catch (Exception e) { return(""); } }
private byte[] Decrypt(byte[] EncData) { byte[] Result = null; try { System.Security.Cryptography.RijndaelManaged Enc = new System.Security.Cryptography.RijndaelManaged(); Enc.KeySize = 256; Enc.Key = this.Encryption_Key(); Enc.IV = this.Encryption_IV(); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(EncData); System.Security.Cryptography.CryptoStream cryptoStream = null; cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, Enc.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Read); byte[] TempDecryptArr = null; TempDecryptArr = new byte[EncData.Length + 1]; int decryptedByteCount = 0; decryptedByteCount = cryptoStream.Read(TempDecryptArr, 0, EncData.Length); cryptoStream.Close(); memoryStream.Close(); cryptoStream.Dispose(); memoryStream.Dispose(); Result = new byte[decryptedByteCount + 1]; Array.Copy(TempDecryptArr, Result, decryptedByteCount); } catch (Exception) { Result = null; } return(Result); }
/// <summary> /// 暗号化された文字列を復号化する /// </summary> /// <param name="sourceString">暗号化された文字列</param> /// <param name="password">暗号化に使用したパスワード</param> /// <returns>復号化された文字列</returns> public static string DecryptString(string text, string password) { //RijndaelManagedオブジェクトを作成 using (var rijndael = new System.Security.Cryptography.RijndaelManaged()) { //パスワードから共有キーと初期化ベクタを作成 GenerateKeyFromPassword(password, rijndael.KeySize, out byte[] key, rijndael.BlockSize, out byte[] iv); rijndael.Key = key; rijndael.IV = iv; //文字列をバイト型配列に戻す byte[] strBytes = System.Convert.FromBase64String(text); //対称暗号化オブジェクトの作成 using (var decryptor = rijndael.CreateDecryptor()) { //バイト型配列を復号化する //復号化に失敗すると例外CryptographicExceptionが発生 byte[] decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); //バイト型配列を文字列に戻して返す return(System.Text.Encoding.UTF8.GetString(decBytes)); } } }
public static string DecodeUserInfoAsString(string encryptedData, string iv, string session_key) { byte[] iv2 = Convert.FromBase64String(iv); if (string.IsNullOrEmpty(encryptedData)) { throw new ArgumentNullException(nameof(encryptedData)); } byte[] toEncryptArray = Convert.FromBase64String(encryptedData); var rm = new System.Security.Cryptography.RijndaelManaged { Key = Convert.FromBase64String(session_key), IV = iv2, Mode = System.Security.Cryptography.CipherMode.CBC, Padding = System.Security.Cryptography.PaddingMode.PKCS7 }; byte[] resultArray; using (rm) { var cTransform = rm.CreateDecryptor(); resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); } return(Encoding.UTF8.GetString(resultArray)); }
public string AesDecrypt(string input) { if (string.IsNullOrEmpty(input) == false) { System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged(); System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider(); try { byte[] hash = new byte[32]; byte[] temp = Hash_AES.ComputeHash(System.Text.Encoding.UTF8.GetBytes(_hashKey)); Array.Copy(temp, 0, hash, 0, 16); Array.Copy(temp, 0, hash, 15, 16); AES.Key = hash; AES.Mode = System.Security.Cryptography.CipherMode.ECB; System.Security.Cryptography.ICryptoTransform DESDecrypter = AES.CreateDecryptor(); byte[] buffer = Convert.FromBase64String(input); var decrypted = System.Text.Encoding.UTF8.GetString(DESDecrypter.TransformFinalBlock(buffer, 0, buffer.Length)); return(decrypted); } catch (Exception) { return(""); } } else { return(""); } }
/// <summary> /// 暗号化された文字列を復号化する /// </summary> /// <param name="sourceString">暗号化された文字列</param> /// <param name="password">暗号化に使用したパスワード</param> /// <returns>復号化された文字列</returns> public static string DecryptString(string sourceString, string password) { if (String.IsNullOrEmpty(sourceString)) { return ""; } //RijndaelManagedオブジェクトを作成 System.Security.Cryptography.RijndaelManaged rijndael = new System.Security.Cryptography.RijndaelManaged(); //パスワードから共有キーと初期化ベクタを作成 byte[] key, iv; GenerateKeyFromPassword( password, rijndael.KeySize, out key, rijndael.BlockSize, out iv); rijndael.Key = key; rijndael.IV = iv; //文字列をバイト型配列に戻す byte[] strBytes = System.Convert.FromBase64String(sourceString); //対称暗号化オブジェクトの作成 System.Security.Cryptography.ICryptoTransform decryptor = rijndael.CreateDecryptor(); //バイト型配列を復号化する byte[] decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); //閉じる decryptor.Dispose(); //バイト型配列を文字列に戻して返す return System.Text.Encoding.UTF8.GetString(decBytes); }
public static string AES_Encrypt(string input_text, string security_Code) { // ''' security_Code= [email protected] System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged(); System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider(); string encrypted = ""; try { byte[] hash = new byte[32]; byte[] temp = Hash_AES.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(security_Code)); Array.Copy(temp, 0, hash, 0, 16); Array.Copy(temp, 0, hash, 15, 16); AES.Key = hash; AES.Mode = System.Security.Cryptography.CipherMode.ECB; //'Security.Cryptography.CipherMode.ECB System.Security.Cryptography.ICryptoTransform DESEncrypter = AES.CreateEncryptor(); byte[] Buffer = System.Text.ASCIIEncoding.ASCII.GetBytes(input_text); encrypted = Convert.ToBase64String(DESEncrypter.TransformFinalBlock(Buffer, 0, Buffer.Length)); } catch (Exception ex) { } return(encrypted); }
public static string Encrypt(string[] keyArray) { string key = ""; foreach (string s in keyArray) { key = key + s + ";"; } byte[] InitialVectorBytes = Encoding.ASCII.GetBytes(InitialVector); byte[] SaltValueBytes = Encoding.ASCII.GetBytes(Salt); byte[] PlainTextBytes = Encoding.UTF8.GetBytes(key); System.Security.Cryptography.PasswordDeriveBytes DerivedPassword = new System.Security.Cryptography.PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations); byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8); System.Security.Cryptography.RijndaelManaged SymmetricKey = new System.Security.Cryptography.RijndaelManaged(); SymmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; byte[] CipherTextBytes = null; using (System.Security.Cryptography.ICryptoTransform Encryptor = SymmetricKey.CreateEncryptor(KeyBytes, InitialVectorBytes)) { using (System.IO.MemoryStream MemStream = new System.IO.MemoryStream()) { using (System.Security.Cryptography.CryptoStream CryptoStream = new System.Security.Cryptography.CryptoStream(MemStream, Encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { CryptoStream.Write(PlainTextBytes, 0, PlainTextBytes.Length); CryptoStream.FlushFinalBlock(); CipherTextBytes = MemStream.ToArray(); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return(Convert.ToBase64String(CipherTextBytes)); }
private static System.Security.Cryptography.SymmetricAlgorithm GetKeyInstance(string algorithm) { System.Security.Cryptography.SymmetricAlgorithm result; switch (algorithm) { case System.Security.Cryptography.Xml.EncryptedXml.XmlEncTripleDESUrl: result = System.Security.Cryptography.TripleDES.Create(); break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES128Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 128; break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES192Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 192; break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES256Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 256; break; default: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 256; break; } return(result); }
private static string Decrypt(string cipherText, string passPhrase) { byte[] initVectorBytes = System.Text.Encoding.ASCII.GetBytes("tu89geji340t89u2"); const int keysize = 256; byte[] cipherTextBytes = Convert.FromBase64String(cipherText); using (System.Security.Cryptography.PasswordDeriveBytes password = new System.Security.Cryptography.PasswordDeriveBytes(passPhrase, null)) { byte[] keyBytes = password.GetBytes(keysize / 8); using (System.Security.Cryptography.RijndaelManaged symmetricKey = new System.Security.Cryptography.RijndaelManaged()) { symmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; using (System.Security.Cryptography.ICryptoTransform decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes)) { using (MemoryStream memoryStream = new MemoryStream(cipherTextBytes)) { using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, decryptor, System.Security.Cryptography.CryptoStreamMode.Read)) { byte[] plainTextBytes = new byte[cipherTextBytes.Length]; int decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); return(System.Text.Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount)); } } } } } }
public static String Encriptar(String input, String pass) { System.Security.Cryptography.RijndaelManaged AES = new System.Security.Cryptography.RijndaelManaged(); System.Security.Cryptography.MD5CryptoServiceProvider Hash_AES = new System.Security.Cryptography.MD5CryptoServiceProvider(); string encrypted = ""; try { byte[] hash = new byte[32]; byte[] temp = Hash_AES.ComputeHash(System.Text.ASCIIEncoding.ASCII.GetBytes(pass)); Array.Copy(temp, 0, hash, 0, 16); Array.Copy(temp, 0, hash, 15, 16); AES.Key = hash; AES.Mode = System.Security.Cryptography.CipherMode.ECB; System.Security.Cryptography.ICryptoTransform DESEncrypter = AES.CreateEncryptor(); byte[] Buffer = System.Text.ASCIIEncoding.ASCII.GetBytes(input); encrypted = Convert.ToBase64String(DESEncrypter.TransformFinalBlock(Buffer, 0, Buffer.Length)); return(encrypted); } catch (Exception ex) { String error = ex.Message; return(null); } }
public static void KriptoFile(string dosyalar, string password = "******", string uzanti = ".uzanti") { System.Security.Cryptography.Rfc2898DeriveBytes rfc = new System.Security.Cryptography.Rfc2898DeriveBytes(password, @byte); System.IO.FileStream fs = new System.IO.FileStream(dosyalar + uzanti, System.IO.FileMode.Create); System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged(); System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(fs, rm.CreateEncryptor(rfc.GetBytes(32), rfc.GetBytes(16)), System.Security.Cryptography.CryptoStreamMode.Write); System.IO.FileStream fs2 = new System.IO.FileStream(dosyalar, System.IO.FileMode.Open, System.IO.FileAccess.Read); int temp; temp = fs2.ReadByte(); while (temp != -1) { cs.WriteByte((byte)temp); temp = fs2.ReadByte(); } //Close işlemleri , silmeyin. Mümkünse hiç bi' yeri ellemeyin. cs.Close(); fs.Close(); fs2.Close(); System.IO.File.Delete(dosyalar); //Bu biraz farklı , ilk önce dosyaların kopyasını oluşturup şifreler. Daha sonra siler. }
public string Descriptografar(string criptografia) { string chave = "--"; // Cria objeto para criptografia AES System.Security.Cryptography.RijndaelManaged rijndael = new System.Security.Cryptography.RijndaelManaged(); rijndael.Mode = System.Security.Cryptography.CipherMode.CBC; rijndael.KeySize = 128; byte[] chaveBytes; byte[] criptografiaBytes; byte[] mensagemBytes; string mensagem; // Transforma chave e mensagem em array de byts chaveBytes = Encoding.UTF8.GetBytes(chave); mensagemBytes = Convert.FromBase64String(criptografia); // Realiza criptografia System.Security.Cryptography.ICryptoTransform cryptor = rijndael.CreateDecryptor(chaveBytes, chaveBytes); criptografiaBytes = cryptor.TransformFinalBlock(mensagemBytes, 0, mensagemBytes.Length); cryptor.Dispose(); // Transforma criptografia em string mensagem = Encoding.UTF8.GetString(criptografiaBytes); return(mensagem); }
public static string Encrypt(string plainText, string passPhrase) { byte[] initVectorBytes = Encoding.ASCII.GetBytes("tu89geji340t89u2"); const int keysize = 256; byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText); using (System.Security.Cryptography.PasswordDeriveBytes password = new System.Security.Cryptography.PasswordDeriveBytes(passPhrase, null)) { byte[] keyBytes = password.GetBytes(keysize / 8); using (System.Security.Cryptography.RijndaelManaged symmetricKey = new System.Security.Cryptography.RijndaelManaged()) { symmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; using (System.Security.Cryptography.ICryptoTransform encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes)) { using (MemoryStream memoryStream = new MemoryStream()) { using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); byte[] cipherTextBytes = memoryStream.ToArray(); return(Convert.ToBase64String(cipherTextBytes)); } } } } } }
public static string decryptRJ256(string target, string key, string iv) { var rijndael = new System.Security.Cryptography.RijndaelManaged() { Padding = System.Security.Cryptography.PaddingMode.Zeros, Mode = System.Security.Cryptography.CipherMode.CBC, KeySize = 256, BlockSize = 256 }; var keyBytes = Encoding.ASCII.GetBytes(key); var ivBytes = Encoding.ASCII.GetBytes(iv); var decryptor = rijndael.CreateDecryptor(keyBytes, ivBytes); var toDecrypt = Convert.FromBase64String(target); var fromEncrypt = new byte[toDecrypt.Length]; var msDecrypt = new System.IO.MemoryStream(toDecrypt); var csDecrypt = new System.Security.Cryptography.CryptoStream(msDecrypt, decryptor, System.Security.Cryptography.CryptoStreamMode.Read); csDecrypt.Read(fromEncrypt, 0, fromEncrypt.Length); string data = Encoding.ASCII.GetString(fromEncrypt); data = data.Replace("\0", ""); return data; }
public string EncryptString(string sourceString, string password) { //RijndaelManagedオブジェクトを作成 System.Security.Cryptography.RijndaelManaged rijndael = new System.Security.Cryptography.RijndaelManaged(); //パスワードから共有キーと初期化ベクタを作成 byte[] key, iv; GenerateKeyFromPassword( password, rijndael.KeySize, out key, rijndael.BlockSize, out iv); rijndael.Key = key; rijndael.IV = iv; //文字列をバイト型配列に変換する byte[] strBytes = System.Text.Encoding.UTF8.GetBytes(sourceString); //対称暗号化オブジェクトの作成 System.Security.Cryptography.ICryptoTransform encryptor = rijndael.CreateEncryptor(); //バイト型配列を暗号化する byte[] encBytes = encryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); //閉じる encryptor.Dispose(); //バイト型配列を文字列に変換して返す return(System.Convert.ToBase64String(encBytes)); }
public RijndaelEncryption(string key, string iv) : base(key, iv) { System.Security.Cryptography.RijndaelManaged rijnManaged = new System.Security.Cryptography.RijndaelManaged(); /* used to generate key and IV */ /* * GenerateKeyIV gen = new GenerateKeyIV(rijnManaged); * string s = Convert.ToBase64String(gen.GenerateKey()); * string sa = Convert.ToBase64String(gen.GenerateIV()); * * rijnManaged.IV = Convert.FromBase64String(sa); * rijnManaged.Key = Convert.FromBase64String(s); * agent = new Crypto.SymmetricEncryption(rijnManaged); * string enc = Convert.ToBase64String(agent.Encrypt(System.Text.ASCIIEncoding.ASCII.GetBytes("sa123"))); */ try { rijnManaged.Key = Convert.FromBase64String(key); rijnManaged.IV = Convert.FromBase64String(iv); agent = new Crypto.SymmetricEncryption(rijnManaged); } catch (System.Security.Cryptography.CryptographicException) { rijnManaged.Dispose(); throw new System.Security.Cryptography.CryptographicException("Invalid key or iv."); } }
/// <summary> /// AES 解密 /// </summary> /// <param name="str">明文(待解密)</param> /// <param name="key">密文</param> /// <returns></returns> public static string AESDecrypt(string str, string key) { if (string.IsNullOrEmpty(str)) { return(null); } if (key.Length < 16) { key = key.PadRight(16, ' '); } else { key = key.Substring(0, 16); } Byte[] toEncryptArray = Convert.FromBase64String(str); System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged { Key = Encoding.UTF8.GetBytes(key), Mode = System.Security.Cryptography.CipherMode.ECB, Padding = System.Security.Cryptography.PaddingMode.PKCS7 }; System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor(); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Encoding.UTF8.GetString(resultArray)); }
public static string Decrypt(string sSrc, string sKey) { try { // if (string.IsNullOrEmpty(sKey) || string.IsNullOrEmpty(sSrc) || sKey.Length != 16) return null; Byte[] toEncryptArray = Convert.FromBase64String(sSrc); System.Security.Cryptography.RijndaelManaged rm = new System.Security.Cryptography.RijndaelManaged { Key = Encoding.UTF8.GetBytes(sKey), Mode = System.Security.Cryptography.CipherMode.ECB, Padding = System.Security.Cryptography.PaddingMode.PKCS7 }; System.Security.Cryptography.ICryptoTransform cTransform = rm.CreateDecryptor(); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Encoding.UTF8.GetString(resultArray)); } catch { return(null); } }
public static string encryptRJ256(string target, string key, string iv) { var rijndael = new System.Security.Cryptography.RijndaelManaged() { Padding = System.Security.Cryptography.PaddingMode.Zeros, Mode = System.Security.Cryptography.CipherMode.CBC, KeySize = 256, BlockSize = 256 }; var bytesKey = Encoding.ASCII.GetBytes(key); var bytesIv = Encoding.ASCII.GetBytes(iv); var encryptor = rijndael.CreateEncryptor(bytesKey, bytesIv); var msEncrypt = new System.IO.MemoryStream(); var csEncrypt = new System.Security.Cryptography.CryptoStream(msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write); var toEncrypt = Encoding.ASCII.GetBytes(target); csEncrypt.Write(toEncrypt, 0, toEncrypt.Length); csEncrypt.FlushFinalBlock(); var encrypted = msEncrypt.ToArray(); return Convert.ToBase64String(encrypted); }
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); System.Security.Cryptography.PasswordDeriveBytes DerivedPassword = new System.Security.Cryptography.PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations); byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8); System.Security.Cryptography.RijndaelManaged SymmetricKey = new System.Security.Cryptography.RijndaelManaged(); SymmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; byte[] PlainTextBytes = new byte[CipherTextBytes.Length]; int ByteCount = 0; using (System.Security.Cryptography.ICryptoTransform Decryptor = SymmetricKey.CreateDecryptor(KeyBytes, InitialVectorBytes)) { using (System.IO.MemoryStream MemStream = new System.IO.MemoryStream(CipherTextBytes)) { using (System.Security.Cryptography.CryptoStream CryptoStream = new System.Security.Cryptography.CryptoStream(MemStream, Decryptor, System.Security.Cryptography.CryptoStreamMode.Read)) { ByteCount = CryptoStream.Read(PlainTextBytes, 0, PlainTextBytes.Length); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return(Encoding.UTF8.GetString(PlainTextBytes, 0, ByteCount)); }
public RijndaelEncryption(string key, string iv) : base(key, iv) { System.Security.Cryptography.RijndaelManaged rijnManaged = new System.Security.Cryptography.RijndaelManaged(); /* used to generate key and IV */ /* GenerateKeyIV gen = new GenerateKeyIV(rijnManaged); string s = Convert.ToBase64String(gen.GenerateKey()); string sa = Convert.ToBase64String(gen.GenerateIV()); rijnManaged.IV = Convert.FromBase64String(sa); rijnManaged.Key = Convert.FromBase64String(s); agent = new Crypto.SymmetricEncryption(rijnManaged); string enc = Convert.ToBase64String(agent.Encrypt(System.Text.ASCIIEncoding.ASCII.GetBytes("sa123"))); */ try { rijnManaged.Key = Convert.FromBase64String(key); rijnManaged.IV = Convert.FromBase64String(iv); agent = new Crypto.SymmetricEncryption(rijnManaged); } catch (System.Security.Cryptography.CryptographicException) { rijnManaged.Dispose(); throw new System.Security.Cryptography.CryptographicException("Invalid key or iv."); } }
/// <summary> /// 文字列を暗号化する /// </summary> /// <param name="sourceString">暗号化する文字列</param> /// <param name="password">暗号化に使用するパスワード</param> /// <returns>暗号化された文字列</returns> public static string EncryptString(string sourceString, string password) { //RijndaelManagedオブジェクトを作成 System.Security.Cryptography.RijndaelManaged rijndael = new System.Security.Cryptography.RijndaelManaged(); //パスワードから共有キーと初期化ベクタを作成 byte[] key, iv; GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv); rijndael.Key = key; rijndael.IV = iv; //文字列をバイト型配列に変換 byte[] strBytes = System.Text.Encoding.UTF8.GetBytes(sourceString); //対称暗号化オブジェクトの作成 System.Security.Cryptography.ICryptoTransform encryptor = rijndael.CreateEncryptor(); //バイト型配列を暗号化する byte[] encBytes = encryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); //閉じる encryptor.Dispose(); //バイト型配列を文字列に変換して返す return System.Convert.ToBase64String(encBytes); }
/// <summary> /// AES 加密 /// </summary> /// <param name="encryptKey"></param> /// <param name="bizContent"></param> /// <param name="charset"></param> /// <returns></returns> public static string AesEncrypt(string encryptKey, string bizContent, string charset) { Byte[] keyArray = Convert.FromBase64String(encryptKey); Byte[] toEncryptArray = null; if (string.IsNullOrEmpty(charset)) { toEncryptArray = Encoding.UTF8.GetBytes(bizContent); } else { toEncryptArray = Encoding.GetEncoding(charset).GetBytes(bizContent); } System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged(); rDel.Key = keyArray; rDel.Mode = System.Security.Cryptography.CipherMode.CBC; rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7; rDel.IV = AES_IV; System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateEncryptor(rDel.Key, rDel.IV); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return(Convert.ToBase64String(resultArray)); }
static Enc() { //RijndaelManagedオブジェクトを作成 rijndael = new System.Security.Cryptography.RijndaelManaged(); byte[] key, iv; GenerateKeyFromPassword(rijndael.KeySize, out key, rijndael.BlockSize, out iv); rijndael.Key = key; rijndael.IV = iv; }
private static async System.Threading.Tasks.Task <ResultType> TaskMain(Fee.Crypt.OnCryptTask_CallBackInterface a_callback_interface, byte[] a_binary, int a_index, int a_length, string a_pass, string a_salt, Fee.TaskW.CancelToken a_cancel) #endif { ResultType t_ret; { t_ret.binary = null; t_ret.errorstring = null; } try{ //RijndaelManaged System.Security.Cryptography.RijndaelManaged t_rijndael = new System.Security.Cryptography.RijndaelManaged(); t_rijndael.KeySize = 256; t_rijndael.BlockSize = 128; t_rijndael.Mode = System.Security.Cryptography.CipherMode.CBC; { byte[] t_salt = System.Text.Encoding.UTF8.GetBytes(a_salt); System.Security.Cryptography.Rfc2898DeriveBytes t_derivebyte = new System.Security.Cryptography.Rfc2898DeriveBytes(a_pass, t_salt); t_derivebyte.IterationCount = 1000; t_rijndael.Key = t_derivebyte.GetBytes(t_rijndael.KeySize / 8); t_rijndael.IV = t_derivebyte.GetBytes(t_rijndael.BlockSize / 8); Tool.Log("Key", System.BitConverter.ToString(t_rijndael.Key)); Tool.Log("IV", System.BitConverter.ToString(t_rijndael.IV)); } //TransformFinalBlock using (System.Security.Cryptography.ICryptoTransform t_decryptor = t_rijndael.CreateDecryptor()){ t_ret.binary = t_decryptor.TransformFinalBlock(a_binary, a_index, a_length); } }catch (System.Exception t_exception) { t_ret.binary = null; t_ret.errorstring = "Task_DecryptPass : "******"Task_DecryptPass : Cancel"; a_cancel.ThrowIfCancellationRequested(); } if (t_ret.binary == null) { if (t_ret.errorstring == null) { t_ret.errorstring = "Task_DecryptPass : null"; } } return(t_ret); }
private void CreateVerifier(byte[] key) { // Much of the commmentary in this function is taken from 2.3.3 // The EncryptionVerifier structure MUST be set using the following process: // 1) Random data are generated and written into the Salt field. // 2) The encryption key is derived from the password and salt, as specified in section // 2.3.4.7 or 2.3.5.2, with block number 0. // This is passed in as parameter key // 3) Generate 16 bytes of additional random data as the Verifier. System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged(); byte[] verifier = aes.IV; aes = null; // Console.WriteLine("Verifier"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(verifier, 32, 0) ); // Console.WriteLine(); // 4) Results of step 3 are encrypted and written into the EncryptedVerifier field. encryptedVerifier = AESEncrypt(verifier, key); // Console.WriteLine("encryptedVerifier"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(encryptedVerifier, 32, 0) ); // Console.WriteLine(); // 5) For the hashing algorithm chosen, obtain the size of the hash data and write this value // into the VerifierHashSize field. // Not applicable right now // 6) Obtain the hashing algorithm output using an input of data generated in step 3. byte[] verifierHash = SHA1Hash(verifier); // Console.WriteLine("verifierHash"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(verifierHash, 32, 0) ); // Console.WriteLine(); // 7) Encrypt the hashing algorithm output from step 6 using the encryption algorithm // chosen, and write the output into the EncryptedVerifierHash field. // First pad to 32 bytes byte[] tempHash = new byte[0x20]; Array.Copy(verifierHash, tempHash, verifierHash.Length); verifierHash = tempHash; encryptedVerifierHash = AESEncrypt(verifierHash, key); // Console.WriteLine("encryptedVerifierHash"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(encryptedVerifierHash, 32, 0) ); // Console.WriteLine(); }
///<summary> ///解密 ///</summary> ///<param name="toDecrypt">需要被解密的数据</param> ///<returns></returns> public static byte[] Decrypt(byte[] toDecrypt) { Byte[] keyArray = System.Text.UTF8Encoding.UTF8.GetBytes(key); System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged(); aes.Key = keyArray; aes.Mode = System.Security.Cryptography.CipherMode.ECB; aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7; System.Security.Cryptography.ICryptoTransform transform = aes.CreateDecryptor(); Byte[] resultArray = transform.TransformFinalBlock(toDecrypt, 0, toDecrypt.Length); return(resultArray); }
/// <summary>Szyfruje przekazany strumień danych.</summary> /// <param name="streamToEncrypt">Strumień danych do zaszyfrowania.</param> /// <param name="streamEncrypted">Zaszyfrowany strumień danych. Uwaga strumień zostanie zamknięty, /// ale w razie konieczności można będzie użyć metody 'ToArray()'.</param> /// <param name="key">Klucz szyfrujący. Maksymalnie 256 bitów, minimalnie 128 bitów, przeskok o 64 bity.</param> /// <param name="iv">Wektor inicjalizacji. Rozmiar 128 bitów.</param> /// <exception cref="System.ArgumentNullException"></exception> /// <exception cref="System.ArgumentException"></exception> /// <exception cref="System.InvalidOperationException"></exception> /// <exception cref="System.Security.Cryptography.CryptographicException"></exception> public static void Encrypt(System.IO.Stream streamToEncrypt, System.IO.Stream streamEncrypted, byte[] key, byte[] iv) { if (streamToEncrypt == null) { throw new System.ArgumentNullException("streamToEncrypt"); } if (streamToEncrypt.CanRead == false) { throw new System.ArgumentException("Argument 'streamToEncrypt' is not readable."); } if (streamEncrypted == null) { throw new System.ArgumentNullException("streamEncrypted"); } if (streamEncrypted.CanWrite == false) { throw new System.ArgumentException("Argument 'streamEncrypted' is not writable."); } if (key == null) { throw new System.ArgumentNullException("key"); } if (key.Length != 16 && key.Length != 22 && key.Length != 32) { throw new System.ArgumentException("Argument 'key' does not mach the block size for this algorithm."); } if (iv == null) { throw new System.ArgumentNullException("iv"); } if (iv.Length != 16) { throw new System.ArgumentException("Argument 'iv' does not mach the block size for this algorithm."); } streamToEncrypt.Position = 0; streamEncrypted.Position = 0; using (System.Security.Cryptography.RijndaelManaged algoritmCrypt = new System.Security.Cryptography.RijndaelManaged()) { using (System.Security.Cryptography.ICryptoTransform encryptor = algoritmCrypt.CreateEncryptor(key, iv)) { using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream( streamEncrypted, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { streamToEncrypt.CopyTo(cs); cs.FlushFinalBlock(); } } } }
/// <summary> /// AES加密 /// </summary> /// <param name="str">要加密字符串</param> /// <returns>返回加密后字符串</returns> public static String Encrypt_AES(String str, String strAesKey) { Byte[] keyArray = System.Text.UTF8Encoding.UTF8.GetBytes(strAesKey); Byte[] toEncryptArray = System.Text.UTF8Encoding.UTF8.GetBytes(str); System.Security.Cryptography.RijndaelManaged rDel = new System.Security.Cryptography.RijndaelManaged(); rDel.Key = keyArray; rDel.Mode = System.Security.Cryptography.CipherMode.ECB; rDel.Padding = System.Security.Cryptography.PaddingMode.PKCS7; System.Security.Cryptography.ICryptoTransform cTransform = rDel.CreateEncryptor(); Byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length); return Convert.ToBase64String(resultArray, 0, resultArray.Length); }
public static string DeCrypt(string strEncryptedInput) { string strReturnValue = null; if (string.IsNullOrEmpty(strEncryptedInput)) { throw new System.ArgumentNullException("strEncryptedInput", "strEncryptedInput may not be string.Empty or NULL, because these are invid values."); } // Dim encASCII As New System.Text.ASCIIEncoding() System.Text.Encoding enc = System.Text.Encoding.UTF8; System.Security.Cryptography.RijndaelManaged objRijndael = new System.Security.Cryptography.RijndaelManaged(); byte[] baCipherTextBuffer = HexStringToByteArray(strEncryptedInput); byte[] baDecryptionKey = HexStringToByteArray(strKey); byte[] baInitializationVector = HexStringToByteArray(strIV); // This is where the message would be transmitted to a recipient // who already knows your secret key. Optionally, you can // also encrypt your secret key using a public key algorithm // and pass it to the mesage recipient along with the RijnDael // encrypted message. //Get a decryptor that uses the same key and IV as the encryptor. System.Security.Cryptography.ICryptoTransform ifaceAESdecryptor = objRijndael.CreateDecryptor(baDecryptionKey, baInitializationVector); //Now decrypt the previously encrypted message using the decryptor // obtained in the above step. System.IO.MemoryStream msDecrypt = new System.IO.MemoryStream(baCipherTextBuffer); System.Security.Cryptography.CryptoStream csDecrypt = new System.Security.Cryptography.CryptoStream(msDecrypt, ifaceAESdecryptor, System.Security.Cryptography.CryptoStreamMode.Read); //Dim baPlainTextBuffer() As Byte //baPlainTextBuffer = New Byte(baCipherTextBuffer.Length) {} byte[] baPlainTextBuffer = new byte[baCipherTextBuffer.Length + 1]; //Read the data out of the crypto stream. csDecrypt.Read(baPlainTextBuffer, 0, baPlainTextBuffer.Length); //Convert the byte array back into a string. strReturnValue = enc.GetString(baPlainTextBuffer); if (!string.IsNullOrEmpty(strReturnValue)) strReturnValue = strReturnValue.Trim('\0'); return strReturnValue; }
public static string Encrypt(string strPlainText) { //Dim roundtrip As String //Dim encASCII As New System.Text.ASCIIEncoding() System.Text.Encoding enc = System.Text.Encoding.UTF8; System.Security.Cryptography.RijndaelManaged objRijndael = new System.Security.Cryptography.RijndaelManaged(); //Dim fromEncrypt() As Byte byte[] baCipherTextBuffer = null; byte[] baPlainTextBuffer = null; byte[] baEncryptionKey = null; byte[] baInitializationVector = null; //Create a new key and initialization vector. //objRijndael.GenerateKey() //objRijndael.GenerateIV() objRijndael.Key = HexStringToByteArray(strKey); objRijndael.IV = HexStringToByteArray(strIV); //Get the key and initialization vector. baEncryptionKey = objRijndael.Key; baInitializationVector = objRijndael.IV; //strKey = ByteArrayToHexString(baEncryptionKey) //strIV = ByteArrayToHexString(baInitializationVector) //Get an encryptor. System.Security.Cryptography.ICryptoTransform ifaceAESencryptor = objRijndael.CreateEncryptor(baEncryptionKey, baInitializationVector); //Encrypt the data. System.IO.MemoryStream msEncrypt = new System.IO.MemoryStream(); System.Security.Cryptography.CryptoStream csEncrypt = new System.Security.Cryptography.CryptoStream(msEncrypt, ifaceAESencryptor, System.Security.Cryptography.CryptoStreamMode.Write); //Convert the data to a byte array. baPlainTextBuffer = enc.GetBytes(strPlainText); //Write all data to the crypto stream and flush it. csEncrypt.Write(baPlainTextBuffer, 0, baPlainTextBuffer.Length); csEncrypt.FlushFinalBlock(); //Get encrypted array of bytes. baCipherTextBuffer = msEncrypt.ToArray(); return ByteArrayToHexString(baCipherTextBuffer); }
// Decrypt a string. public static string DecryptString(string sourceString, string password) { System.Security.Cryptography.RijndaelManaged rijndael = new System.Security.Cryptography.RijndaelManaged(); byte[] key, iv; GenerateKeyFromPassword( password, rijndael.KeySize, out key, rijndael.BlockSize, out iv); rijndael.Key = key; rijndael.IV = iv; byte[] strBytes = System.Convert.FromBase64String(sourceString); System.Security.Cryptography.ICryptoTransform decryptor = rijndael.CreateDecryptor(); byte[] decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); decryptor.Dispose(); return System.Text.Encoding.UTF8.GetString(decBytes); }
/// <summary> /// 文字列を復号化 /// </summary> /// <param name="sourceString">暗号化文字列</param> /// <param name="password">パスワード</param> /// <returns>復号化後文字列</returns> public string DecryptString(string sourceString, string password) { byte[] key, iv, strBytes, decBytes; System.Security.Cryptography.RijndaelManaged rijndael; System.Security.Cryptography.ICryptoTransform decryptor; // 複合化(コンバートあり) try { // v2.0 rijndael = new System.Security.Cryptography.RijndaelManaged(); GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv, 100); rijndael.Key = key; rijndael.IV = iv; strBytes = System.Convert.FromBase64String(sourceString); decryptor = rijndael.CreateDecryptor(); decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); decryptor.Dispose(); } catch (Exception) { try { // v1.0-1.3 rijndael = new System.Security.Cryptography.RijndaelManaged(); GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv, 1000); rijndael.Key = key; rijndael.IV = iv; strBytes = System.Convert.FromBase64String(sourceString); decryptor = rijndael.CreateDecryptor(); decBytes = decryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); decryptor.Dispose(); } catch (Exception) { throw; } } return System.Text.Encoding.UTF8.GetString(decBytes); }
public static string GenerateKey() { System.Security.Cryptography.RijndaelManaged objRijndael = new System.Security.Cryptography.RijndaelManaged(); objRijndael.GenerateKey(); objRijndael.GenerateIV(); byte[] bIV = objRijndael.IV; byte[] bKey = objRijndael.Key; objRijndael.Clear(); return "IV: " + ByteArrayToHexString(bIV) + System.Environment.NewLine + "Key: " + ByteArrayToHexString(bKey); }
public static string Decrypt(string CipherText, string Password, string Salt, string HashAlgorithm, 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); System.Security.Cryptography.PasswordDeriveBytes DerivedPassword = new System.Security.Cryptography.PasswordDeriveBytes(Password, SaltValueBytes, HashAlgorithm, PasswordIterations); byte[] KeyBytes = DerivedPassword.GetBytes(KeySize / 8); System.Security.Cryptography.RijndaelManaged SymmetricKey = new System.Security.Cryptography.RijndaelManaged(); SymmetricKey.Mode = System.Security.Cryptography.CipherMode.CBC; byte[] PlainTextBytes = new byte[CipherTextBytes.Length]; int ByteCount = 0; using (System.Security.Cryptography.ICryptoTransform Decryptor = SymmetricKey.CreateDecryptor(KeyBytes, InitialVectorBytes)) { using (MemoryStream MemStream = new MemoryStream(CipherTextBytes)) { using (System.Security.Cryptography.CryptoStream CryptoStream = new System.Security.Cryptography.CryptoStream(MemStream, Decryptor, System.Security.Cryptography.CryptoStreamMode.Read)) { ByteCount = CryptoStream.Read(PlainTextBytes, 0, PlainTextBytes.Length); MemStream.Close(); CryptoStream.Close(); } } } SymmetricKey.Clear(); return Encoding.UTF8.GetString(PlainTextBytes, 0, ByteCount); }
private byte[] Decrypt(byte[] EncData) { byte[] Result = null; try { System.Security.Cryptography.RijndaelManaged Enc = new System.Security.Cryptography.RijndaelManaged(); Enc.KeySize = 256; Enc.Key = this.Encryption_Key(); Enc.IV = this.Encryption_IV(); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(EncData); System.Security.Cryptography.CryptoStream cryptoStream = null; cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, Enc.CreateDecryptor(), System.Security.Cryptography.CryptoStreamMode.Read); byte[] TempDecryptArr = null; TempDecryptArr = new byte[EncData.Length + 1]; int decryptedByteCount = 0; decryptedByteCount = cryptoStream.Read(TempDecryptArr, 0, EncData.Length); cryptoStream.Close(); memoryStream.Close(); cryptoStream.Dispose(); memoryStream.Dispose(); Result = new byte[decryptedByteCount + 1]; Array.Copy(TempDecryptArr, Result, decryptedByteCount); } catch (Exception) { Result = null; } return Result; }
/// <summary> /// Encrypts a package (zip) file using a supplied password and returns /// an array to create an encryption information stream and a byte array /// of the encrypted package. /// </summary> /// <param name="packageContents">The package (zip) file to be encrypted</param> /// <param name="password">The password to decrypt the package</param> /// <param name="encryptionInfo">An array of bytes containing the encrption info</param> /// <param name="encryptedPackage">The encrpyted package</param> /// <returns></returns> public void EncryptPackage(byte[] packageContents, string password, out byte[] encryptionInfo, out byte[] encryptedPackage) { versionMajor = 3; versionMinor = 2; // Console.WriteLine(password); // this.algId = AlgId.AES256; // this.keySize = 0x100; // Generate a salt System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged(); saltSize = 0x10; byte[] tempSalt = SHA1Hash(aes.IV); aes = null; this.verifierHashSize = tempSalt.Length; salt = new byte[saltSize]; Array.Copy(tempSalt, salt, saltSize); // Generate a key from salt and password byte[] key = GeneratePasswordHashUsingSHA1(password); CreateVerifier(key); int originalLength = packageContents.Length; // Pad the array to the nearest 16 byte boundary int remainder = packageContents.Length % 0x10; if (remainder != 0) { byte[] tempContents = new byte[packageContents.Length + 0x10 - remainder]; Array.Copy(packageContents, tempContents, packageContents.Length); packageContents = tempContents; } byte[] encryptionResult = AESEncrypt(packageContents, key); // Need to prepend the original package size as a Int64 (8 byte) field encryptedPackage = new byte[encryptionResult.Length + 8]; // MUST record the original length here Array.Copy(BitConverter.GetBytes((long)originalLength), encryptedPackage, 8); Array.Copy(encryptionResult, 0, encryptedPackage, 8, encryptionResult.Length); byte[] encryptionHeader = null; // Generate the encryption header structure using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { System.IO.BinaryWriter br = new System.IO.BinaryWriter(ms); br.Write((int)this.encryptionFlags); br.Write((int)this.sizeExtra); br.Write((int)this.algId); br.Write((int)this.algHashId); br.Write((int)this.keySize); br.Write((int)this.providerType); br.Write(new byte[] { 0xA0, 0xC7, 0xDC, 0x02, 0x00, 0x00, 0x00, 0x00 } ); br.Write(System.Text.UnicodeEncoding.Unicode.GetBytes("Microsoft Enhanced RSA and AES Cryptographic Provider (Prototype)\0")); ms.Flush(); encryptionHeader = ms.ToArray(); } byte[] encryptionVerifier = null; // Generate the encryption header structure using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { System.IO.BinaryWriter br = new System.IO.BinaryWriter(ms); br.Write((int)salt.Length); br.Write(this.salt); br.Write(this.encryptedVerifier); br.Write(this.verifierHashSize); // Hash length br.Write(this.encryptedVerifierHash); ms.Flush(); encryptionVerifier = ms.ToArray(); } // Now generate the encryption info structure using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { System.IO.BinaryWriter br = new System.IO.BinaryWriter(ms); br.Write(versionMajor); br.Write(versionMinor); br.Write((int)this.encryptionFlags); br.Write((int)encryptionHeader.Length); br.Write(encryptionHeader); br.Write(encryptionVerifier); ms.Flush(); encryptionInfo = ms.ToArray(); } // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(encryptionInfo, 128, 0) ); }
private byte[] Encrypt(byte[] PlainData) { byte[] Result = null; try { System.Security.Cryptography.RijndaelManaged Enc = new System.Security.Cryptography.RijndaelManaged(); Enc.KeySize = 256; Enc.Key = this.Encryption_Key(); Enc.IV = this.Encryption_IV(); System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(); System.Security.Cryptography.CryptoStream cryptoStream = null; cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, Enc.CreateEncryptor(), System.Security.Cryptography.CryptoStreamMode.Write); cryptoStream.Write(PlainData, 0, PlainData.Length); cryptoStream.FlushFinalBlock(); Result = memoryStream.ToArray(); cryptoStream.Close(); memoryStream.Close(); cryptoStream.Dispose(); memoryStream.Dispose(); } catch (Exception) { Result = null; } return Result; }
private byte[] AESDecrypt(byte[] data, int index, int count, byte[] key) { byte[] decryptedBytes = null; // Create uninitialized Rijndael encryption object. System.Security.Cryptography.RijndaelManaged symmetricKey = new System.Security.Cryptography.RijndaelManaged(); // It is required that the encryption mode is Electronic Codebook (ECB) // see MS-OFFCRYPTO v1.0 2.3.4.7 pp 39. symmetricKey.Mode = System.Security.Cryptography.CipherMode.ECB; symmetricKey.Padding = System.Security.Cryptography.PaddingMode.None; symmetricKey.KeySize = keySize; // symmetricKey.IV = null; // new byte[16]; // symmetricKey.Key = key; // 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(key, null); // Define memory stream which will be used to hold encrypted data. using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream(data, index, count)) { // Define memory stream which will be used to hold encrypted data. using (System.Security.Cryptography.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. decryptedBytes = new byte[data.Length]; int decryptedByteCount = cryptoStream.Read(decryptedBytes, 0, decryptedBytes.Length); return decryptedBytes; } } }
//[MenuItem("Hugula AES/GenerateKey", false, 12)] public static void GenerateKey() { using (System.Security.Cryptography.RijndaelManaged myRijndael = new System.Security.Cryptography.RijndaelManaged()) { myRijndael.GenerateKey(); byte[] Key = myRijndael.Key; KeyVData KeyScri = ScriptableObject.CreateInstance<KeyVData>(); KeyScri.KEY = Key; AssetDatabase.CreateAsset(KeyScri, Path.Combine(ConfigPath, "I81.asset")); Debug.Log("key Generate " + Key.Length); } }
bool ProcessEncryptionPwd() { System.Security.Cryptography.Rfc2898DeriveBytes pbkdf2 = null; if (tbEncryptionPwd.Text == "[UNCHANGED]") // Password hasn't changed from when the package was loaded return true; if (string.IsNullOrEmpty(tbEncryptionPwd.Text)) return true; // Nothing to do really if (!string.IsNullOrEmpty(virtPackage.GetProperty("EncryptionPwdKey")) && !string.IsNullOrEmpty(virtPackage.GetProperty("EncryptionPwdHash")) && !string.IsNullOrEmpty(virtPackage.GetProperty("EncryptionPwdSalt")) && !string.IsNullOrEmpty(virtPackage.GetProperty("EncryptionPwdIV"))) { // EncryptionPwd* properties are already set. Only need to re-generate them if password has changed (different from EncryptionPwdHash) string pwdSaltStr = virtPackage.GetProperty("EncryptionPwdSalt"); var pwdSalt = Utils.HexUndump(pwdSaltStr); // Check if password is unchanged // PBKDF2 first time on entered password pbkdf2 = new System.Security.Cryptography.Rfc2898DeriveBytes(tbEncryptionPwd.Text, pwdSalt, Pbkdf2Iterations); var enteredPwdHash = pbkdf2.GetBytes(KeySizeBytes); // PBKDF2 second time on entered password pbkdf2 = new System.Security.Cryptography.Rfc2898DeriveBytes(enteredPwdHash, pwdSalt, Pbkdf2Iterations); enteredPwdHash = pbkdf2.GetBytes(KeySizeBytes); var savedPwdHash = Utils.HexUndump(virtPackage.GetProperty("EncryptionPwdHash")); bool equals = true; for (int i = 0; i < enteredPwdHash.Length; i++) { if (enteredPwdHash[i] != savedPwdHash[i]) equals = false; } if (equals) return true; // Password hasn't changed } bool Ret = true; var rngCsp = new System.Security.Cryptography.RNGCryptoServiceProvider(); // Steps for password-based key: // 1. Generate a long key (this is just a randomly generated amount of bytes in hex, you can use 128 bytes). // Use this key to encrypt your file with AES (meaning you use it as a password) byte[] randomKey = new byte[KeySizeBytes]; // Our AES algorithm uses a 128-bit key (16 bytes) rngCsp.GetBytes(randomKey); // <-- The key with which files will be encrypted / decrypted // 2. Encrypt the key itself with AES using your password (which is a bit shorter but easier to remember. // Now AES requires this again to be either 128, 192 or 256 bits of length so you need to make your // password of that length. Hence you can just use PBKDF2 (or scrypt or bcrypt) to create a fixed key // length from your password. DO NOT STORE THIS. byte[] salt = new byte[SaltSize]; rngCsp.GetBytes(salt); // Transform user password into a key that we can encrypt randomKey with pbkdf2 = new System.Security.Cryptography.Rfc2898DeriveBytes(Encoding.ASCII.GetBytes(tbEncryptionPwd.Text), salt, Pbkdf2Iterations); var keyEncryptionKey = pbkdf2.GetBytes(KeySizeBytes); // tbEncryptionPwd.Text -> Key. This key will be used for encrypting randomKey. var keyEncryptor = new System.Security.Cryptography.RijndaelManaged(); keyEncryptor.BlockSize = 128; keyEncryptor.Mode = System.Security.Cryptography.CipherMode.CFB; keyEncryptor.Padding = System.Security.Cryptography.PaddingMode.None; keyEncryptor.Key = keyEncryptionKey; keyEncryptor.GenerateIV(); var encryptor = keyEncryptor.CreateEncryptor(keyEncryptor.Key, keyEncryptor.IV); var msEncrypt = new MemoryStream(); using (var csEncrypt = new System.Security.Cryptography.CryptoStream(msEncrypt, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { using (var swEncrypt = new BinaryWriter(csEncrypt)) { byte[] toWrite = randomKey;//Encoding.ASCII.GetBytes("1234567890123456"); swEncrypt.Write(toWrite); } } var encryptedKey = msEncrypt.ToArray(); // <-- randomKey encrypted with AES, whose key = PBKDF2(tbEncryptionPwd.Text) // 3. Keep a hash of your hashed password using PBKDF2 (or bcrypt or scrypt). This will allow you to check // if the password is correct before trying to decrypt your encrypted key: // hash(hash(password)) --> can be stored // hash(password) --> should not be stored pbkdf2 = new System.Security.Cryptography.Rfc2898DeriveBytes(keyEncryptionKey, salt, Pbkdf2Iterations); // Iterations slow down hashing (which helps against brute-force) var keyEncryptionKeyHashed = pbkdf2.GetBytes(KeySizeBytes); // Second PBKDF2 hash // Store Ret &= virtPackage.SetProperty("EncryptionPwdKey", Utils.HexDump(encryptedKey)); // Encryption key, in encrypted form Ret &= virtPackage.SetProperty("EncryptionPwdHash", Utils.HexDump(keyEncryptionKeyHashed)); // Password hash, for user password validation Ret &= virtPackage.SetProperty("EncryptionPwdSalt", Utils.HexDump(salt)); // Salt used for both PBKDF2 password hashes (first and second) Ret &= virtPackage.SetProperty("EncryptionPwdIV", Utils.HexDump(keyEncryptor.IV)); // IV used for encrypting the key with AES return Ret; }
/// <summary> /// 文字列を暗号化 /// </summary> /// <param name="sourceString">暗号化文字列</param> /// <param name="password">暗号化パスワード</param> /// <returns>暗号化後文字列</returns> public string EncryptString(string sourceString, string password) { byte[] key, iv, strBytes, encBytes; System.Security.Cryptography.RijndaelManaged rijndael; System.Security.Cryptography.ICryptoTransform encryptor; try { rijndael = new System.Security.Cryptography.RijndaelManaged(); GenerateKeyFromPassword(password, rijndael.KeySize, out key, rijndael.BlockSize, out iv, 100); rijndael.Key = key; rijndael.IV = iv; strBytes = System.Text.Encoding.UTF8.GetBytes(sourceString); encryptor = rijndael.CreateEncryptor(); encBytes = encryptor.TransformFinalBlock(strBytes, 0, strBytes.Length); encryptor.Dispose(); } catch (Exception) { throw; } return System.Convert.ToBase64String(encBytes); }
/// <summary> /// Initializa os objetos necessários para realizar criptografia e descriptografia. /// </summary> private void Initialize() { System.Security.Cryptography.RijndaelManaged v_rijndael; System.Security.Cryptography.Rfc2898DeriveBytes v_passwordbytes; byte[] v_initvectorbytes; byte[] v_keybytes; v_rijndael = new System.Security.Cryptography.RijndaelManaged(); v_rijndael.Mode = System.Security.Cryptography.CipherMode.CBC; v_initvectorbytes = System.Text.Encoding.ASCII.GetBytes(this.v_initvector); v_passwordbytes = new System.Security.Cryptography.Rfc2898DeriveBytes(this.v_password, v_initvectorbytes, 1); v_keybytes = v_passwordbytes.GetBytes(this.v_keysize / 8); this.v_encryptor = v_rijndael.CreateEncryptor(v_keybytes, v_initvectorbytes); this.v_decryptor = v_rijndael.CreateDecryptor(v_keybytes, v_initvectorbytes); }
private byte[] AESEncrypt(byte[] data, byte[] key) { byte[] cipherTextBytes = null; // Create uninitialized Rijndael encryption object. System.Security.Cryptography.RijndaelManaged symmetricKey = new System.Security.Cryptography.RijndaelManaged(); // It is required that the encryption mode is Electronic Codebook (ECB) // see MS-OFFCRYPTO v1.0 2.3.4.7 pp 39. symmetricKey.Mode = System.Security.Cryptography.CipherMode.ECB; symmetricKey.Padding = System.Security.Cryptography.PaddingMode.None; // System.Security.Cryptography.PaddingMode.None; symmetricKey.KeySize = this.keySize; // symmetricKey.Key = key; // symmetricKey.IV = new byte[16]; // Generate encryptor 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 encryptor = symmetricKey.CreateEncryptor(key, null); // Define memory stream which will be used to hold encrypted data. using (System.IO.MemoryStream memoryStream = new System.IO.MemoryStream()) { // Define cryptographic stream (always use Write mode for encryption). using (System.Security.Cryptography.CryptoStream cryptoStream = new System.Security.Cryptography.CryptoStream(memoryStream, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { // Start encrypting. cryptoStream.Write(data, 0, data.Length); // Finish encrypting. cryptoStream.FlushFinalBlock(); } // Convert our encrypted data from a memory stream into a byte array. cipherTextBytes = memoryStream.ToArray(); return cipherTextBytes; } }
//[MenuItem("Hugula AES/GenerateIV", false, 13)] public static void GenerateIV() { using (System.Security.Cryptography.RijndaelManaged myRijndael = new System.Security.Cryptography.RijndaelManaged()) { myRijndael.GenerateIV(); byte[] IV = myRijndael.IV; KeyVData KeyScri = ScriptableObject.CreateInstance<KeyVData>(); KeyScri.IV = IV; AssetDatabase.CreateAsset(KeyScri, Path.Combine(ConfigPath, "K81.asset")); Debug.Log("IV Generate " + IV.Length); } }
private static System.Security.Cryptography.SymmetricAlgorithm GetKeyInstance(string algorithm) { System.Security.Cryptography.SymmetricAlgorithm result; switch (algorithm) { case System.Security.Cryptography.Xml.EncryptedXml.XmlEncTripleDESUrl: result = System.Security.Cryptography.TripleDES.Create(); break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES128Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 128; break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES192Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 192; break; case System.Security.Cryptography.Xml.EncryptedXml.XmlEncAES256Url: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 256; break; default: result = new System.Security.Cryptography.RijndaelManaged(); result.KeySize = 256; break; } return result; }
private void CreateVerifier(byte[] key) { // Much of the commmentary in this function is taken from 2.3.3 // The EncryptionVerifier structure MUST be set using the following process: // 1) Random data are generated and written into the Salt field. // 2) The encryption key is derived from the password and salt, as specified in section // 2.3.4.7 or 2.3.5.2, with block number 0. // This is passed in as parameter key // 3) Generate 16 bytes of additional random data as the Verifier. System.Security.Cryptography.RijndaelManaged aes = new System.Security.Cryptography.RijndaelManaged(); byte[] verifier = aes.IV; aes = null; // Console.WriteLine("Verifier"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(verifier, 32, 0) ); // Console.WriteLine(); // 4) Results of step 3 are encrypted and written into the EncryptedVerifier field. encryptedVerifier = AESEncrypt( verifier, key); // Console.WriteLine("encryptedVerifier"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(encryptedVerifier, 32, 0) ); // Console.WriteLine(); // 5) For the hashing algorithm chosen, obtain the size of the hash data and write this value // into the VerifierHashSize field. // Not applicable right now // 6) Obtain the hashing algorithm output using an input of data generated in step 3. byte[] verifierHash = SHA1Hash( verifier ); // Console.WriteLine("verifierHash"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(verifierHash, 32, 0) ); // Console.WriteLine(); // 7) Encrypt the hashing algorithm output from step 6 using the encryption algorithm // chosen, and write the output into the EncryptedVerifierHash field. // First pad to 32 bytes byte[] tempHash = new byte[0x20]; Array.Copy(verifierHash, tempHash, verifierHash.Length); verifierHash = tempHash; encryptedVerifierHash = AESEncrypt( verifierHash, key ); // Console.WriteLine("encryptedVerifierHash"); // Console.WriteLine( Lyquidity.OLEStorage.Utilities.FormatData(encryptedVerifierHash, 32, 0) ); // Console.WriteLine(); }