public String EncryptIt(String s) { Encoding byteEncoder = Encoding.UTF8; byte[] rijnKey = byteEncoder.GetBytes("h504lXb1erd4ilw7"); //this is key for encrypt data byte[] rijnIV = byteEncoder.GetBytes("4hx7e4bwM15d0CrL"); //this is iv for encrypt data String result; AesManaged rijn = new AesManaged(); //Using AES-128 rijn.KeySize = 128; rijn.BlockSize = 128; using (MemoryStream msEncrypt = new MemoryStream()) { using (ICryptoTransform encryptor = rijn.CreateEncryptor(rijnKey, rijnIV)) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(s); } } } result = Convert.ToBase64String(msEncrypt.ToArray()); } rijn.Clear(); return result; }
public static string Encrypt(string plainText, string key) { if (string.IsNullOrEmpty(plainText)) throw new ArgumentNullException("plainText"); if (string.IsNullOrEmpty(key)) throw new ArgumentNullException("key"); using (var keyDerivationFunction = new Rfc2898DeriveBytes(key, _saltSize)) { var saltBytes = keyDerivationFunction.Salt; var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream()) { using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) using (var streamWriter = new StreamWriter(cryptoStream)) streamWriter.Write(plainText); var cipherTextBytes = memoryStream.ToArray(); Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length); Array.Copy(cipherTextBytes, 0, saltBytes, _saltSize, cipherTextBytes.Length); return Convert.ToBase64String(saltBytes); } } }
/// <summary> /// Encrypts the plainText input using the given Key. /// A 128 bit random salt will be generated and prepended to the ciphertext before it is returned. /// </summary> /// <param name="plainText">The plain text to encrypt.</param> /// <param name="password">The plain text encryption key.</param> /// <returns>The salt and the ciphertext</returns> public static byte[] Encrypt(byte[] plainText, string password) { if (plainText == null || plainText.Length == 0) throw new ArgumentNullException("plainText"); if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password"); // Derive a new Salt, Key, and IV from the password using (var keyDerivationFunction = new Rfc2898DeriveBytes(password, SaltSize)) { var saltBytes = keyDerivationFunction.Salt; var keyBytes = keyDerivationFunction.GetBytes(32); var ivBytes = keyDerivationFunction.GetBytes(16); using (var aesManaged = new AesManaged()) using (var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) using (var memoryStream = new MemoryStream()) using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) { using (var streamWriter = new BinaryWriter(cryptoStream)) { streamWriter.Write(plainText); } var cipherTextBytes = memoryStream.ToArray(); Array.Resize(ref saltBytes, saltBytes.Length + cipherTextBytes.Length); Array.Copy(cipherTextBytes, 0, saltBytes, SaltSize, cipherTextBytes.Length); return saltBytes; } } }
public Secret Encrypt(string plainText) { Secret result = new Secret(); using (MemoryStream ms = new MemoryStream()) { using (Aes aesAlg = new AesManaged()) { aesAlg.Key = _key; result.IV = aesAlg.IV; ICryptoTransform encryptor = aesAlg.CreateEncryptor(); using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { byte[] rawPlaintext = Encoding.Unicode.GetBytes(plainText); cs.Write(rawPlaintext, 0, rawPlaintext.Length); cs.FlushFinalBlock(); // get the encrypted text ms.Seek(0, SeekOrigin.Begin); byte[] content = new byte[ms.Length]; ms.Read(content, 0, content.Length); result.Data = content; } } } return result; }
public static bool ForCodeCoverage() { AesManaged aes = new AesManaged(); using (ICryptoTransform cte = aes.CreateEncryptor(), ctd = aes.CreateDecryptor()) { byte[] plain1 = new byte[64]; for (int i = 0; i < plain1.Length; i++) plain1[i] = (byte)i; byte[] encr1 = cte.TransformFinalBlock(plain1, 0, plain1.Length); using(MemoryStream ms = new MemoryStream()) using(CryptoStream cs = new CryptoStream(ms, ctd, CryptoStreamMode.Write)) { cs.Write(encr1, 0, 16); cs.Write(encr1, 16, 16); cs.Write(encr1, 32, 16); cs.Write(encr1, 48, encr1.Length-48); cs.FlushFinalBlock(); byte[] plain2 = ms.ToArray(); if (!Compare(plain1, plain2)) { Console.WriteLine("CodeCoverage case failed"); return false; } return true; } } }
public static byte[] EncryptStringToBytes(string plainText, byte[] key, byte[] IV) { byte[] encrypted; using (Aes aesAlg = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IV, 0, IV.Length), key); aesAlg.Key = deriveBytes.GetBytes(128 / 8); aesAlg.IV = aesAlg.Key; ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(plainText); } encrypted = msEncrypt.ToArray(); } } } return encrypted; }
/// <summary>Encrypt the given string using AES. The string can be decrypted using /// DecryptStringAes(). The sharedSecret parameters must match.</summary> /// <param name="plainText">The text to encrypt.</param> /// <param name="sharedSecret">A password used to generate a key for encryption.</param> /// <param name="salt">The salt used for encryption.</param> /// <returns></returns> public static string EncryptStringAes(string plainText, string sharedSecret, string salt) { Guard.AgainstNullOrEmpty(plainText); Guard.AgainstNullOrEmpty(sharedSecret); Guard.AgainstNullOrEmpty(salt); try { using (var key = new Rfc2898DeriveBytes(sharedSecret, Encoding.ASCII.GetBytes(salt))) using (var aesManaged = new AesManaged()) { aesManaged.Key = key.GetBytes(aesManaged.KeySize / 8); aesManaged.IV = key.GetBytes(aesManaged.BlockSize / 8); using (var encryptor = aesManaged.CreateEncryptor(aesManaged.Key, aesManaged.IV)) using (var memoryStream = new MemoryStream()) using (var cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write)) using (var streamWriter = new StreamWriter(cryptoStream)) { //Write all data to the stream. streamWriter.Write(plainText); streamWriter.Close(); return Convert.ToBase64String(memoryStream.ToArray()); } } } catch { return string.Empty; } }
public static string Encrypt(this string text) { if (string.IsNullOrEmpty(text)) { return null; } byte[] rawPlaintext = System.Text.Encoding.Unicode.GetBytes(text); byte[] cipherText = null; using (Aes aes = new AesManaged()) { aes.Padding = PaddingMode.PKCS7; aes.KeySize = AesKeySizeInBits; int KeyStrengthInBytes = aes.KeySize / 8; System.Security.Cryptography.Rfc2898DeriveBytes rfc2898 = new System.Security.Cryptography.Rfc2898DeriveBytes(Password, Salt, Rfc2898KeygenIterations); aes.Key = rfc2898.GetBytes(KeyStrengthInBytes); aes.IV = rfc2898.GetBytes(KeyStrengthInBytes); using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(rawPlaintext, 0, rawPlaintext.Length); } cipherText = ms.ToArray(); } return ByteArrayToString(cipherText); } }
public void DecryptsToOriginalPlainText() { byte[] plaintextBytes = Encoding.UTF8.GetBytes("This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least. This is a test! It needs to be 128 characters long at least."); byte[] decryptedBytes; using (SymmetricAlgorithm algorithm = new AesManaged()) { byte[] wrongDecryptionKey = algorithm.Key; algorithm.GenerateKey(); byte[] encryptionKey = algorithm.Key; Assert.AreNotEqual(encryptionKey, wrongDecryptionKey); byte[] ciphertextBytes, iv; using (Encryptor encryptor = algorithm.CreateEncryptor(encryptionKey, out iv)) { Assert.AreEqual(encryptionKey, encryptor.Algorithm.Key); Assert.AreEqual(iv, encryptor.Algorithm.IV); ciphertextBytes = encryptor.Encrypt(plaintextBytes); } using (Decryptor decryptor = new Decryptor(algorithm, encryptionKey, iv, Encryption.DefaultOptions)) { Assert.AreEqual(encryptionKey, decryptor.Algorithm.Key); Assert.AreEqual(iv, decryptor.Algorithm.IV); decryptedBytes = decryptor.Decrypt(ciphertextBytes); } } Assert.AreEqual(plaintextBytes, decryptedBytes); }
internal static void EncryptFile(string inputFile, string outputFile, string password) { try { var UE = new UnicodeEncoding(); byte[] key = UE.GetBytes(password); string cryptFile = outputFile; var fsCrypt = new FileStream(cryptFile, FileMode.Create); var AesMngd = new AesManaged(); var cs = new CryptoStream(fsCrypt, AesMngd.CreateEncryptor(key, key), CryptoStreamMode.Write); using (var fsIn = new FileStream(inputFile, FileMode.Open)) { int data; while ((data = fsIn.ReadByte()) != -1) cs.WriteByte((byte)data); } cs.Close(); fsCrypt.Close(); } catch { Shared.MSGBOX(Shared.GetRes("#D.02#","Error"),"Encryption failed!",System.Windows.Application.Current.MainWindow); } }
public string Encrypt(byte[] key, string dataToEncrypt) { // Initialize AesManaged encryptor = new AesManaged(); // Set the key encryptor.Key = key; encryptor.IV = key; // create a memory stream using (MemoryStream encryptionStream = new MemoryStream()) { // Create the crypto stream using ( CryptoStream encrypt = new CryptoStream(encryptionStream, encryptor.CreateEncryptor(), CryptoStreamMode.Write)) { // Encrypt byte[] utfD1 = UTF8Encoding.UTF8.GetBytes(dataToEncrypt); encrypt.Write(utfD1, 0, utfD1.Length); encrypt.FlushFinalBlock(); encrypt.Close(); // Return the encrypted data return Convert.ToBase64String(encryptionStream.ToArray()); } } }
public byte[] EncryptAES(ParametroEntreda Entrada) { if (Entrada.plainText == null || Entrada.plainText.Length <= 0) throw new ArgumentNullException("plainText"); if (Entrada.Key == null || Entrada.Key.Length <= 0) throw new ArgumentNullException("Key"); if (Entrada.IV == null || Entrada.IV.Length <= 0) throw new ArgumentNullException("Key"); byte[] encrypted; using (AesManaged aesAlg = new AesManaged()) { aesAlg.Key = Entrada.Key; aesAlg.IV = Entrada.IV; ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(Entrada.plainText); } encrypted = msEncrypt.ToArray(); } } } return encrypted; }
public static string Encrypt(string key, string text) { // Our symmetric encryption algorithm AesManaged aes = new AesManaged(); // We're using the PBKDF2 standard for password-based key generation Rfc2898DeriveBytes rfc = new Rfc2898DeriveBytes("password", Encoding.UTF8.GetBytes(key)); // Setting our parameters aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); // Encryption ICryptoTransform encryptTransf = aes.CreateEncryptor(); // Output stream, can be also a FileStream MemoryStream encryptStream = new MemoryStream(); CryptoStream encryptor = new CryptoStream(encryptStream, encryptTransf, CryptoStreamMode.Write); byte[] utfData = Encoding.Unicode.GetBytes(text); encryptor.Write(utfData, 0, utfData.Length); encryptor.Flush(); encryptor.Close(); // return encrypted content return Convert.ToBase64String(encryptStream.ToArray()); }
public static string Encrypt(string plainText, string key) { if(string.IsNullOrEmpty(plainText)) { throw new ArgumentNullException("plainText"); } if(string.IsNullOrEmpty(key)) { throw new ArgumentNullException("key"); } using(var keyDerivationFunction = new Rfc2898DeriveBytes(key, SALT_SIZE)) { byte[] saltBytes = keyDerivationFunction.Salt; byte[] keyBytes = keyDerivationFunction.GetBytes(32); byte[] ivBytes = keyDerivationFunction.GetBytes(16); using(var aesManaged = new AesManaged()) { aesManaged.KeySize = 256; using(var encryptor = aesManaged.CreateEncryptor(keyBytes, ivBytes)) { MemoryStream memoryStream = null; CryptoStream cryptoStream = null; return WriteMemoryStream(plainText, ref saltBytes, encryptor, ref memoryStream, ref cryptoStream); } } } }
public static string EncryptText(string textToEncrypt, string key, string salt) { if (string.IsNullOrWhiteSpace(textToEncrypt)) return null; if (string.IsNullOrWhiteSpace(key)) return null; if (string.IsNullOrWhiteSpace(salt)) return null; using (MemoryStream ms = new MemoryStream()) { try { using (AesManaged aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(key, Encoding.UTF8.GetBytes(salt)); aes.Key = deriveBytes.GetBytes(128 / 8); ms.Write(BitConverter.GetBytes(aes.IV.Length), 0, sizeof(int)); ms.Write(aes.IV, 0, aes.IV.Length); using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write)) { byte[] bytesFromText = Encoding.Unicode.GetBytes(textToEncrypt); cs.Write(bytesFromText, 0, bytesFromText.Length); cs.FlushFinalBlock(); } return BytesToBase64String(ms.ToArray());// Return the encrypted bytes from the memory stream and convert to Base64 } } catch { return null; } } }
//平文から暗号化バイト配列を生成して返す static byte[] EncryptStringToBytes_Aes(string str,string password) { if (string.IsNullOrEmpty(str)) throw new ArgumentNullException("plainText"); if (password == null || password.Length <= 0) throw new ArgumentNullException("key"); byte[] encrypted; using (AesManaged aesAlg = new AesManaged()) { byte[] key, iv; GenerateKeyFromPassword(password, aesAlg.KeySize, out key, aesAlg.BlockSize, out iv); aesAlg.Key = key; aesAlg.IV = iv; ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(str); } encrypted = msEncrypt.ToArray(); } } } return encrypted; }
public static void EncryptFile(string inputFile, string outputFile, string skey) { try { using (Aes aes = new AesManaged()) { var key = new Rfc2898DeriveBytes(skey, salt); aes.Key = key.GetBytes(aes.KeySize / 8); aes.IV = key.GetBytes(aes.BlockSize / 8); using (FileStream fsCrypt = new FileStream(outputFile, FileMode.Create)) { using (ICryptoTransform encryptor = aes.CreateEncryptor()) { using (CryptoStream cs = new CryptoStream(fsCrypt, encryptor, CryptoStreamMode.Write)) { using (FileStream fsIn = new FileStream(inputFile, FileMode.Open)) { int data; while ((data = fsIn.ReadByte()) != -1) { cs.WriteByte((byte)data); } } } } } } } catch { throw; } }
/// <summary> /// <see cref="IAesManagedWrapper.Encrypt"/> /// </summary> public byte[] Encrypt(byte[] bytesToBeEncrypted, byte[] aesKey, out byte[] aesIv) { byte[] encryptedBytes; using (var ms = new MemoryStream()) { using (var aes = new AesManaged()) { SetStandardConfiguration(aes); aes.Key = aesKey; aes.GenerateIV(); aesIv = aes.IV; using (var cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length); cs.Close(); } encryptedBytes = ms.ToArray(); } } return encryptedBytes; }
public static byte[] Encrypt(string text, string password, byte[] salt = null) { if (string.IsNullOrEmpty(text)) throw new ArgumentNullException("text"); if (string.IsNullOrEmpty(password)) throw new ArgumentNullException("password"); if (salt == null) salt = DefaultSalt; var aes = new AesManaged(); byte[] encryptedData; try { aes.SetKey(password, salt); var encryptor = aes.CreateEncryptor(aes.Key, aes.IV); using (var ms = new MemoryStream()) { ms.Write(BitConverter.GetBytes(aes.IV.Length), 0, sizeof(int)); ms.Write(aes.IV, 0, aes.IV.Length); using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) using (var sw = new StreamWriter(cs)) sw.Write(text); encryptedData = ms.ToArray(); } } finally { aes.Clear(); } return encryptedData; }
static byte[] EncryptedStringToBytes_Aes(string plainText, byte[] key, byte[] IV) { if (plainText == null || plainText.Length <= 0) throw new ArgumentNullException("plainText"); if (key == null || key.Length <= 0) throw new ArgumentNullException("key"); if (IV == null || IV.Length <= 0) throw new ArgumentNullException("SAL"); byte[] encrypted; using (AesManaged aesAlg = new AesManaged()) { aesAlg.Key = key; aesAlg.IV = IV; ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV); using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { swEncrypt.Write(plainText); } encrypted = msEncrypt.ToArray(); } } } return encrypted; }
public BlockConsensusRequest CreateRequest(MinerWallet wallet) { lock (SyncRoot) { if (!Valid) throw new InvalidOperationException(); if (request == null) { request = new BlockConsensusRequest { PrevHash = PrevHash, Miner = my_pubkey, NonceHash = NonceHashes[my_pubkey], TransactionHashes = TransactionHashes.ToArray() }; SplitSecret secret = SecretSharing.Split(Nonces[my_pubkey].ToArray(), (Miners.Length - 1) / 2 + 1); for (int i = 0; i < Miners.Length; i++) { if (Miners[i].Equals(my_pubkey)) continue; byte[] aeskey = wallet.GetAesKey(Miners[i]); byte[] iv = aeskey.Take(16).ToArray(); byte[] piece = secret.GetShare(i + 1).ToArray(); using (AesManaged aes = new AesManaged()) using (ICryptoTransform encryptor = aes.CreateEncryptor(aeskey, iv)) { piece = encryptor.TransformFinalBlock(piece, 0, piece.Length); } Array.Clear(aeskey, 0, aeskey.Length); Array.Clear(iv, 0, iv.Length); request.NoncePieces.Add(Miners[i], piece); } } return request; } }
/// <summary> /// Encrypt a string using AES /// </summary> /// <param name="Str">String to encrypt</param> /// <param name="Password">Encryption password</param> /// <param name="Salt">A salt string (at least 8 bytes)</param> /// <returns>Encrypted string in case of success; otherwise - empty string</returns> public static string EncryptString(string Str, string Password = "******", string Salt = "tdcm1234") { try { using (Aes aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Password, Encoding.UTF8.GetBytes(Salt)); aes.Key = deriveBytes.GetBytes(128 / 8); aes.IV = aes.Key; using (MemoryStream encryptionStream = new MemoryStream()) { using (CryptoStream encrypt = new CryptoStream(encryptionStream, aes.CreateEncryptor(), CryptoStreamMode.Write)) { byte[] utfD1 = UTF8Encoding.UTF8.GetBytes(Str); encrypt.Write(utfD1, 0, utfD1.Length); encrypt.FlushFinalBlock(); } return Convert.ToBase64String(encryptionStream.ToArray()); } } } catch (Exception ex) { Debug.WriteLine("Error : AES ~ EncryptString ; " + ex.Message); return ""; } }
public static byte[] Encrypt(byte[] input) { if (_key == null || _key.Length == 0) throw new Exception("Key can not be empty."); if (input == null || input.Length == 0) throw new ArgumentException("Input can not be empty."); byte[] data = input, encdata = new byte[0]; try { using (var ms = new MemoryStream()) { using (var rd = new AesManaged { Key = _key }) { rd.GenerateIV(); using (var cs = new CryptoStream(ms, rd.CreateEncryptor(), CryptoStreamMode.Write)) { ms.Write(rd.IV, 0, rd.IV.Length); // write first 16 bytes IV, followed by encrypted message cs.Write(data, 0, data.Length); } } encdata = ms.ToArray(); } } catch { } return encdata; }
internal static byte[] Encrypt(byte[] data) { byte[] output = null; using (var aes = new AesManaged()) { using (var encryptor = aes.CreateEncryptor(Configuration.Default.EncryptionKey, Configuration.Default.EncryptionIV)) { using (var dataStream = new MemoryStream()) { using (var encryptionStream = new CryptoStream(dataStream, encryptor, CryptoStreamMode.Write)) { encryptionStream.Write(data, 0, data.Length); encryptionStream.FlushFinalBlock(); dataStream.Position = 0; byte[] transformedBytes = new byte[dataStream.Length]; dataStream.Read(transformedBytes, 0, transformedBytes.Length); encryptionStream.Close(); dataStream.Close(); output = transformedBytes; } } } } return output; }
/// <summary> /// 加密 /// </summary> public static string AESEncrypt(string input) { byte[] data = System.Text.UTF8Encoding.UTF8.GetBytes(input); byte[] salt = System.Text.UTF8Encoding.UTF8.GetBytes(saltValue); // AesManaged - 高级加密标准(AES) 对称算法的管理类 System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged( ); // Rfc2898DeriveBytes - 通过使用基于 HMACSHA1 的伪随机数生成器,实现基于密码的密钥派生功能 (PBKDF2 - 一种基于密码的密钥派生函数) // 通过 密码 和 salt 派生密钥 System.Security.Cryptography.Rfc2898DeriveBytes rfc = new System.Security.Cryptography.Rfc2898DeriveBytes(pwdValue, salt); aes.BlockSize = aes.LegalBlockSizes[0].MaxSize; aes.KeySize = aes.LegalKeySizes[0].MaxSize; aes.Key = rfc.GetBytes(aes.KeySize / 8); aes.IV = rfc.GetBytes(aes.BlockSize / 8); // 用当前的 Key 属性和初始化向量 IV 创建对称加密器对象 System.Security.Cryptography.ICryptoTransform encryptTransform = aes.CreateEncryptor( ); // 加密后的输出流 System.IO.MemoryStream encryptStream = new System.IO.MemoryStream( ); // 将加密后的目标流(encryptStream)与加密转换(encryptTransform)相连接 System.Security.Cryptography.CryptoStream encryptor = new System.Security.Cryptography.CryptoStream (encryptStream, encryptTransform, System.Security.Cryptography.CryptoStreamMode.Write); // 将一个字节序列写入当前 CryptoStream (完成加密的过程) encryptor.Write(data, 0, data.Length); encryptor.Close( ); // 将加密后所得到的流转换成字节数组,再用Base64编码将其转换为字符串 string encryptedString = Convert.ToBase64String(encryptStream.ToArray( )); return(encryptedString); }
// should be used to encrypt a key with another key public static string EncryptWithKey(this string plaintext, string hexkey, string iv) { byte[] key = hexkey.ToByteArray (); byte[] byte_iv = iv.ToByteArray (); var aes = new AesManaged (); if (key.Length != 16 && key.Length != 20 && key.Length != 32) throw new Exception ("Key must be 128, 192 or 256 bits"); ICryptoTransform encryptor = aes.CreateEncryptor (key, byte_iv); // Create the streams used for encryption. using (MemoryStream msEncrypt = new MemoryStream()) { using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { //Write all data to the stream. swEncrypt.Write(plaintext); } var encrypted = msEncrypt.ToArray(); return encrypted.ToHexString (); } } }
public byte[] Encrypt(string plainText, byte[] Key, byte[] IV) { byte[] encrypted; // Create a new AesManaged. using (System.Security.Cryptography.AesManaged aes = new System.Security.Cryptography.AesManaged()) { // Create encryptor System.Security.Cryptography.ICryptoTransform encryptor = aes.CreateEncryptor(Key, IV); // Create MemoryStream using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { // Create crypto stream using the CryptoStream class. This class is the key to encryption // and encrypts and decrypts data from any given stream. In this case, we will pass a memory stream // to encrypt using (System.Security.Cryptography.CryptoStream cs = new System.Security.Cryptography.CryptoStream(ms, encryptor, System.Security.Cryptography.CryptoStreamMode.Write)) { // Create StreamWriter and write data to a stream using (System.IO.StreamWriter sw = new System.IO.StreamWriter(cs)) sw.Write(plainText); encrypted = ms.ToArray(); } } } // Return encrypted data return(encrypted); }
///<summary>Encrypts signature text and returns a base 64 string so that it can go directly into the database.</summary> public static string Encrypt(string str,byte[] key){ //No need to check RemotingRole; no call to db. if(str==""){ return ""; } byte[] ecryptBytes=Encoding.UTF8.GetBytes(str); MemoryStream ms=new MemoryStream(); CryptoStream cs=null; Aes aes=new AesManaged(); aes.Key=key; aes.IV=new byte[16]; ICryptoTransform encryptor=aes.CreateEncryptor(aes.Key,aes.IV); cs=new CryptoStream(ms,encryptor,CryptoStreamMode.Write); cs.Write(ecryptBytes,0,ecryptBytes.Length); cs.FlushFinalBlock(); byte[] encryptedBytes=new byte[ms.Length]; ms.Position=0; ms.Read(encryptedBytes,0,(int)ms.Length); cs.Dispose(); ms.Dispose(); if(aes!=null) { aes.Clear(); } return Convert.ToBase64String(encryptedBytes); }
public static string Encrypt(this string text, string lKey) { try { using (Aes aes = new AesManaged()) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(Encoding.UTF8.GetString(IVa, 0, IVa.Length), Encoding.UTF8.GetBytes(lKey)); aes.Key = deriveBytes.GetBytes(128 / 8); aes.IV = aes.Key; using (MemoryStream encryptionStream = new MemoryStream()) { using (CryptoStream encrypt = new CryptoStream(encryptionStream, aes.CreateEncryptor(), CryptoStreamMode.Write)) { byte[] cleanText = Encoding.UTF8.GetBytes(text); encrypt.Write(cleanText, 0, cleanText.Length); encrypt.FlushFinalBlock(); } byte[] encryptedData = encryptionStream.ToArray(); string encryptedText = Convert.ToBase64String(encryptedData); return encryptedText; } } } catch { return String.Empty; } }
public static string encrypt(string valueToEncrypt) { using (Aes aes = new AesManaged()) { aes.Padding = PaddingMode.PKCS7; aes.KeySize = 128; // in bits aes.Key = new byte[128 / 8]; // 16 bytes for 128 bit encryption aes.IV = new byte[128 / 8]; // AES needs a 16-byte IV // Should set Key and IV here. Good approach: derive them from // a password via Cryptography.Rfc2898DeriveBytes byte[] cipherText = null; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(UTF8Encoding.UTF8.GetBytes(valueToEncrypt), 0, valueToEncrypt.Length); } cipherText = ms.ToArray(); } return Convert.ToBase64String(cipherText); } }
/// <summary> /// Encrypts the string using the Advanced Encryption Standard (AES) symmetric algorithm. /// </summary> /// <param name="plainText">The plain string to be encypted.</param> /// <param name="key">The secret key to use for the symmetric algorithm.</param> /// <param name="iv">The initialization vector to use for the symmetric algorithm.</param> /// <returns>A byte array containing the encypted string.</returns> public static byte[] EncryptString(string plainText, byte[] key, byte[] iv) { // Check arguments. if (string.IsNullOrEmpty(plainText)) throw new ArgumentNullException("plainText"); if (key == null || key.Length <= 0) throw new ArgumentNullException("key"); if (iv == null || iv.Length <= 0) throw new ArgumentNullException("iv"); using (var msEncrypt = new MemoryStream()) using (var aes = new AesManaged()) { aes.Key = key; aes.IV = iv; ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV); using (var csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) using (var swEncrypt = new StreamWriter(csEncrypt)) swEncrypt.Write(plainText); return msEncrypt.ToArray(); } }
public int dbEncrypt(String partition, int size, String data, out String dataOut) { AesManaged aes = null; MemoryStream memoryStream = null; CryptoStream cryptoStream = null; try { aes = new AesManaged(); aes.Key = readKeyFromFile(partition); memoryStream = new MemoryStream(); cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write); byte[] buf = Encoding.UTF8.GetBytes(data); cryptoStream.Write(buf, 0, buf.Length); cryptoStream.FlushFinalBlock(); dataOut = Convert.ToBase64String(memoryStream.ToArray()); } finally { if (cryptoStream != null) cryptoStream.Close(); if (memoryStream != null) memoryStream.Close(); if (aes != null) aes.Clear(); } return getErrorCode() == 0 ? 1 : 0; }
private void CreateCrytoTransform() { // Get shared secret GetSharedSecret(ref key, ref iv); if (key.Length == 0) { return; } // Set transform AesManaged aes = new System.Security.Cryptography.AesManaged(); AesManaged aes_decrypt = new AesManaged(); aes.Key = key; aes.IV = iv; aes.Mode = System.Security.Cryptography.CipherMode.CBC; aes.Padding = System.Security.Cryptography.PaddingMode.PKCS7; aes.BlockSize = 128; transform = aes.CreateEncryptor(); aes_decrypt.Key = key; aes_decrypt.IV = iv; aes_decrypt.Mode = System.Security.Cryptography.CipherMode.CBC; aes_decrypt.Padding = System.Security.Cryptography.PaddingMode.None; aes_decrypt.BlockSize = 128; decryptTransform = aes_decrypt.CreateDecryptor(); }