private static string GetEncryptedString(byte[] OriginalKeyInByteArr, byte[] IVBytes, string PlainText) { byte[] encrypted; AesCryptoServiceProvider myAes = new AesCryptoServiceProvider(); myAes.Key = OriginalKeyInByteArr; myAes.IV = IVBytes; AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider(); ICryptoTransform encryptor = aesAlg.CreateEncryptor(myAes.Key, myAes.IV); 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); } encrypted = msEncrypt.ToArray(); } } var encryptedInBase64 = Convert.ToBase64String(encrypted); var encryptedInHex = GetHexStringFromBytes(encrypted); return encryptedInHex; }
void Button1Click(object sender, EventArgs e) { //if (save_encrypt.ShowDialog() == DialogResult.OK) //{ FileStream encrypt_file = File.Create(openfile.FileName+"_encrypt"); AesCryptoServiceProvider AES_ALGORITHM = new AesCryptoServiceProvider(); CryptoStream csEncrypt = new CryptoStream(encrypt_file, AES_ALGORITHM.CreateEncryptor(),CryptoStreamMode.Write); StreamWriter swEncStream = new StreamWriter(csEncrypt); StreamReader srFile = new StreamReader(textBox1.Text); string currLine = srFile.ReadLine(); while(currLine != null) { swEncStream.WriteLine(currLine); currLine = srFile.ReadLine(); } srFile.Close(); swEncStream.Flush(); swEncStream.Close(); FileStream keyfile = File.Create(openfile.FileName+".key"); BinaryWriter binFile = new BinaryWriter(keyfile); key = AES_ALGORITHM.Key; iv = AES_ALGORITHM.IV; binFile.Write(AES_ALGORITHM.Key); binFile.Write(AES_ALGORITHM.IV); binFile.Flush(); binFile.Close(); //} }
private static byte[] AliceSendData(string msg) { Console.WriteLine(string.Format("Alice Send Msg: {0}", msg)); byte[] rawdata = Encoding.UTF8.GetBytes(msg); byte[] encryptedData = null; using (var aliceAlgorithm = new ECDiffieHellmanCng(aliceKey)) using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob)) { byte[] symmkey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey); Console.WriteLine(string.Format("Alice Create this symmtric key with {0}", Convert.ToBase64String(symmkey))); var aes = new AesCryptoServiceProvider(); aes.Key = symmkey; aes.GenerateIV(); using (ICryptoTransform encryptor = aes.CreateEncryptor()) using (MemoryStream ms = new MemoryStream()) { var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write); ms.Write(aes.IV, 0, aes.IV.Length); cs.Write(rawdata, 0, rawdata.Length); cs.Close(); encryptedData = ms.ToArray(); } aes.Clear(); } Console.WriteLine(Convert.ToBase64String(encryptedData)); return encryptedData; }
public static byte[] Encrypt(byte[] data, string privateKey) { // We hash the private key string to ensure we have a key with the correct // number of bytes. var privateKeyHash = HashKey(privateKey); using (var provider = new AesCryptoServiceProvider()) { provider.Key = privateKeyHash; provider.Mode = CipherMode.CBC; provider.Padding = PaddingMode.PKCS7; using (var ms = new MemoryStream()) { ms.Write(provider.IV, 0, 16); using (var encryptor = provider.CreateEncryptor()) { using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { cs.Write(data, 0, data.Length); cs.FlushFinalBlock(); } return ms.ToArray(); } } } }
/// <summary> /// AES加密 /// </summary> /// <param name="data">待加密数据</param> /// <param name="key">密钥</param> /// <returns>密文字节数组</returns> public static byte[] AesEncrypt(string data, byte[] key) { byte[] result; using (SymmetricAlgorithm algorithm = new AesCryptoServiceProvider()) { algorithm.Mode = CipherMode.ECB; algorithm.Padding = PaddingMode.PKCS7; using (ICryptoTransform transform = algorithm.CreateEncryptor(key, key)) { using (MemoryStream ms = new MemoryStream()) { using (Stream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { using (StreamWriter writer = new StreamWriter(cs)) { writer.Write(data); } result = ms.ToArray(); } } } } return result; }
string CreateEncryptedSensitiveVariablesFile(string fileName, string encryptionPassword, Dictionary<string, string> variables) { using (var algorithm = new AesCryptoServiceProvider { Key = Calamari.Deployment.SensitiveVariables.GetEncryptionKey(encryptionPassword) }) using (var encryptor = algorithm.CreateEncryptor()) using (var encryptedTextStream = new MemoryStream()) using (var jsonStream = new MemoryStream()) using (var streamWriter = new StreamWriter(jsonStream, Encoding.UTF8)) using (var jsonWriter = new JsonTextWriter(streamWriter)) { using (var cryptoStream = new CryptoStream(encryptedTextStream, encryptor, CryptoStreamMode.Write)) { var serializer = new JsonSerializer(); serializer.Serialize(jsonWriter, variables); jsonWriter.Flush(); streamWriter.Flush(); var jsonBytes = jsonStream.ToArray(); cryptoStream.Write(jsonBytes, 0, jsonBytes.Length); } var encryptedBytes = encryptedTextStream.ToArray(); fileSystem.OverwriteFile(fileName, Convert.ToBase64String(encryptedBytes)); return Convert.ToBase64String(algorithm.IV); } }
/// <summary> /// AES Encryption /// </summary> public static string Encrypt(string clearText) { if (clearText == null) return null; // AesCryptoServiceProvider AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); aes.BlockSize = 128; aes.KeySize = 128; aes.GenerateIV(); aes.Key = Encoding.UTF8.GetBytes(AesKey); aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; // Convert string to byte array byte[] src = Encoding.Unicode.GetBytes(clearText); // encryption using (ICryptoTransform encrypt = aes.CreateEncryptor()) { byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length); // Convert byte array to Base64 strings return Convert.ToBase64String(aes.IV) + Convert.ToBase64String(dest); } }
public static string Encrypt(long id) { byte[] encrypted; using (var aesAlg = new AesCryptoServiceProvider()) { aesAlg.Key = AesCryptoServiceProvider.Key; aesAlg.IV = AesCryptoServiceProvider.IV; 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(id); } encrypted = msEncrypt.ToArray(); } } } return Convert.ToBase64String(encrypted); }
protected override string EncryptByBlocks(byte[] key, List<byte> plainText) { var cipherText = new StringBuilder(); if (plainText.Count % BlockSize == 0) { AddDummyBlock(plainText); } using (var aes = new AesCryptoServiceProvider()) { aes.BlockSize = BlockSize * 8; aes.KeySize = KeySize * 8; aes.Padding = PaddingMode.None; aes.Key = key; aes.GenerateIV(); cipherText.Append(BytesToHexString(aes.IV)); using (var encr = aes.CreateEncryptor()) { while (plainText.Count != 0) { var block = DetachBlock(plainText); if (block.Length < BlockSize) { block = CompleteBlock(block); } var encrypted = new byte[BlockSize]; encr.TransformBlock(block, 0, BlockSize, encrypted, 0); cipherText.Append(BytesToHexString(encrypted)); aes.IV = encrypted; } } } return cipherText.ToString(); }
public byte[] Encription(string message, byte[] bobPubKeyBlob) { byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using (var aliceAlgorithm = new ECDiffieHellmanCng(privKey)) using (CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.EccPublicBlob)) { byte[] symmKey = aliceAlgorithm.DeriveKeyMaterial(bobPubKey); using (var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using (ICryptoTransform encryptor = aes.CreateEncryptor()) using (MemoryStream ms = new MemoryStream()) { // create CryptoStream and encrypt data to send var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write); // write initialization vector not encrypted ms.Write(aes.IV, 0, aes.IV.Length); cs.Write(rawData, 0, rawData.Length); cs.Close(); encryptedData = ms.ToArray(); } aes.Clear(); } } return encryptedData; }
/// <summary> /// Encryptes a string using 3DES /// </summary> /// <param name="data">The data to encrypt</param> /// <param name="key">The key to use</param> /// <param name="IV">Initialization Vector</param> /// <returns>An encrypted, base64 encoded string</returns> public static byte[] EncryptAES(string data, byte[] key, byte[] IV) { string retVal = string.Empty; var tsp = new System.Security.Cryptography.AesCryptoServiceProvider(); // default padding and mode tsp.Mode = CipherMode.CBC; tsp.Padding = PaddingMode.PKCS7; // get a crypt transform interface ICryptoTransform ct = tsp.CreateEncryptor(key, IV); // setup a memory stream MemoryStream ms = new MemoryStream(); using (CryptoStream cs = new CryptoStream(ms, ct, CryptoStreamMode.Write)) { // write the string through the crypto stream byte[] db = System.Text.Encoding.ASCII.GetBytes(data); cs.Write(db, 0, db.Length); // flush cs.FlushFinalBlock(); // convert the data in the memory stream to base64 text ms.Seek(0, SeekOrigin.Begin); var edata = ms.ToArray(); return edata; } }
/// <summary> /// Encrypts a plainText string using the system key retrieved from the Web Service /// </summary> /// <param name="plainText">String to encrypt</param> /// <returns>EncryptedData with encrypted string and IV used</returns> public EncryptedData Encrypt(string plainText) { lock (_locker) { using (var crypto = new AesCryptoServiceProvider()) { try { UnprotectKey(); // Create the streams used for encryption. using (MemoryStream msEncrypt = new MemoryStream()) using (var encryptor = crypto.CreateEncryptor(_key, crypto.IV)) using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write)) { using (StreamWriter swEncrypt = new StreamWriter(csEncrypt)) { //Write all data to the stream. swEncrypt.Write(plainText); } return new EncryptedData(msEncrypt.ToArray(), crypto.IV); } } finally { ProtectKey(); } } } }
/// <summary> /// uses the AES FIPS-140 compliant algorithm to encrypt a string /// </summary> /// <param name="plainText">the text to encrypt</param> /// <param name="passPhrase">the pass phase to do the encryption</param> /// <param name="salt">a salt value to ensure ciphertext using the same text/password is different</param> /// <param name="iterations">number of iterations to derive the key (higher is slower but more secure) - optional parameter with a default of 1000</param> /// <returns></returns> public static String EncryptAES(String plainText, String passPhrase, String salt, int iterations = 1000) { VerifyAesSettings(passPhrase, salt); byte[] saltBytes = Encoding.ASCII.GetBytes(salt); var aesProvider = new AesCryptoServiceProvider(); var derivedBytes = new Rfc2898DeriveBytes(passPhrase, saltBytes, iterations); Byte[] derivedKey = derivedBytes.GetBytes(32); // 256 bits Byte[] derivedInitVector = derivedBytes.GetBytes(16); // 128 bits Byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText); aesProvider.KeySize = 256; aesProvider.Padding = PaddingMode.ISO10126; aesProvider.Mode = CipherMode.CBC; ICryptoTransform encryptor = aesProvider.CreateEncryptor(derivedKey, derivedInitVector); var memStream = new MemoryStream(); var cryptoStream = new CryptoStream(memStream, encryptor, CryptoStreamMode.Write); cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); cryptoStream.FlushFinalBlock(); Byte[] cipherTextBytes = memStream.ToArray(); memStream.Close(); cryptoStream.Close(); return Convert.ToBase64String(cipherTextBytes); }
public void SetUp() { using ( AesCryptoServiceProvider aesAlg = new AesCryptoServiceProvider() ) { m_Encryptor = aesAlg.CreateEncryptor(); m_Decryptor = aesAlg.CreateDecryptor(); } }
public void Encrypt(string filename) { FileStream fsInput = new FileStream(filename, FileMode.Open, FileAccess.Read); FileStream fsOutput = new FileStream(filename + ".crypt", FileMode.Create, FileAccess.Write); AesCryptoServiceProvider Aes = new AesCryptoServiceProvider(); Aes.KeySize = 128; Aes.GenerateIV(); Aes.GenerateKey(); byte[] output = _algorithm_asym.Encrypt(Aes.Key, false); fsOutput.Write(output, 0, 256); output = _algorithm_asym.Encrypt(Aes.IV, false); fsOutput.Write(output, 0, 256); ICryptoTransform encrypt = Aes.CreateEncryptor(); CryptoStream cryptostream = new CryptoStream(fsOutput, encrypt, CryptoStreamMode.Write); byte[] bytearrayinput = new byte[fsInput.Length - 1]; fsInput.Read(bytearrayinput, 0, bytearrayinput.Length); cryptostream.Write(bytearrayinput, 0, bytearrayinput.Length); fsInput.Close(); fsOutput.Close(); }
/// <summary> /// AES encryption /// </summary> public string Encrypt(string text) { // AES cryptographic service provider AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); aes.BlockSize = 128; aes.KeySize = 128; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; aes.IV = Encoding.UTF8.GetBytes(AesIV); aes.Key = Encoding.UTF8.GetBytes(AesKey); // String → byte byte[] src = Encoding.Unicode.GetBytes(text); //encryption using (ICryptoTransform encrypt = aes.CreateEncryptor()) { byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length); // byte→Base64 return Convert.ToBase64String(dest); } }
public static byte[] Encrypt(byte[] input, byte[] key) { if (key == null || key.Length == 0) throw new Exception("Key can not be empty."); using (var md5 = new MD5CryptoServiceProvider()) { key = md5.ComputeHash(key); } byte[] data = input, encdata = new byte[0]; try { using (var ms = new MemoryStream()) { using (var aesProvider = new AesCryptoServiceProvider() { Key = key }) { aesProvider.GenerateIV(); using (var cs = new CryptoStream(ms, aesProvider.CreateEncryptor(), CryptoStreamMode.Write)) { ms.Write(aesProvider.IV, 0, aesProvider.IV.Length); // write first 16 bytes IV, followed by encrypted message cs.Write(data, 0, data.Length); } } encdata = ms.ToArray(); } } catch { } return encdata; }
public static byte[] EncryptString(byte[] toEncrypt, byte[] encryptionKey) { if (encryptionKey == null || encryptionKey.Length == 0) throw new ArgumentException("encryptionKey"); using (var provider = new AesCryptoServiceProvider()) { provider.Key = encryptionKey; provider.Mode = CipherMode.CBC; provider.Padding = PaddingMode.PKCS7; using (var encryptor = provider.CreateEncryptor(provider.Key, provider.IV)) { using (var ms = new MemoryStream()) { using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { cs.Write(toEncrypt, 0, toEncrypt.Length); cs.FlushFinalBlock(); var retVal = new byte[16 + ms.Length]; provider.IV.CopyTo(retVal, 0); ms.ToArray().CopyTo(retVal, 16); return retVal; } } } } }
public static void EncryptAndUpload(string file, string awsPath, string key) { if (bool.Parse(ConfigurationManager.AppSettings["ManagedEncryption"])) { Rfc2898DeriveBytes deriveBytes = new Rfc2898DeriveBytes(key, appKey); using (var aes = new AesCryptoServiceProvider()) { aes.Key = deriveBytes.GetBytes(aes.KeySize / 8); aes.IV = deriveBytes.GetBytes(aes.BlockSize / 8); using (var temp = new FileStream(file + "_encrypted", FileMode.Create)) { using (var stream = new CryptoStream(new FileStream(file, FileMode.Open), aes.CreateEncryptor(), CryptoStreamMode.Read)) { stream.CopyTo(temp); } } UploadFile(file + "_encrypted", awsPath); File.Delete(file + "_encrypted"); } } else UploadFile(file, awsPath); }
public static byte[] Protect(byte[] encryptionKey, byte[] validationKey, byte[] initializationVector, byte[] plainText) { using (var provider = new AesCryptoServiceProvider()) { using (ICryptoTransform transform = provider.CreateEncryptor(encryptionKey, initializationVector)) { using (var ms = new MemoryStream()) { ms.Write(initializationVector, 0, initializationVector.Length); using (var cryptoStream = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { // Encrypted payload cryptoStream.Write(plainText, 0, plainText.Length); cryptoStream.FlushFinalBlock(); // Compute signature using (var sha = new HMACSHA256(validationKey)) { checked { byte[] signature = sha.ComputeHash(ms.GetBuffer(), 0, (int)ms.Length); // Write the signature to the paylod ms.Write(signature, 0, signature.Length); // Final bytes return ms.ToArray(); } } } } } } }
public static string AESEncryptor(string plainText, byte[] Key, byte[] IV) { byte[] data = ASCIIEncoding.ASCII.GetBytes(plainText); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); string encryptedString = Convert.ToBase64String(aes.CreateEncryptor(Key, IV).TransformFinalBlock(data, 0, data.Length)); return encryptedString; }
public ICryptoTransform CreateEncryptor(byte[] key, byte[] iv) { using (var provider = new AesCryptoServiceProvider {Padding = _paddingMode}) { return provider.CreateEncryptor(key, iv); } }
public static byte[] EncryptString(string toEncrypt, byte[] encryptionKey) { if (string.IsNullOrEmpty(toEncrypt)) throw new ArgumentException("toEncrypt"); if (encryptionKey == null || encryptionKey.Length == 0) throw new ArgumentException("encryptionKey"); var toEncryptBytes = Encoding.UTF8.GetBytes(toEncrypt); using (var provider = new AesCryptoServiceProvider()) { provider.Key = encryptionKey; provider.Mode = CipherMode.CBC; provider.Padding = PaddingMode.PKCS7; using (var encryptor = provider.CreateEncryptor(provider.Key, provider.IV)) { using (var ms = new MemoryStream()) { ms.Write(provider.IV, 0, 16); using (var cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write)) { cs.Write(toEncryptBytes, 0, toEncryptBytes.Length); cs.FlushFinalBlock(); } return ms.ToArray(); } } } }
public static string Request(string requestParams, string devKey, string devIV, string devID) { // Create an unencrypted request as an array of bytes byte[] request = UTF8Encoding.UTF8.GetBytes(requestParams); byte[] key = UTF8Encoding.UTF8.GetBytes(devKey); byte[] iv = UTF8Encoding.UTF8.GetBytes(devIV); AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); aes.Key = key; aes.IV = iv; aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.Zeros; // Get the transformer from the AES Encryptor ICryptoTransform cTransform = aes.CreateEncryptor(); // Use the transformer to encrypt our request byte[] result = cTransform.TransformFinalBlock(request, 0, request.Length); aes.Clear(); // Encode to base64 string encryptedRequest = Convert.ToBase64String(result, 0, result.Length); // Send request to API string requestUri = "http://api.blackoutrugby.com/?d=" + devID + "&er=" + encryptedRequest; string xmlResponse = getWebResponse(requestUri); return XmlToJson(xmlResponse); }
public static string encriptar(string texto, string key) { AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); MD5 md5Hash = MD5.Create(); string chave = GetMd5Hash(md5Hash, key); aes.Key = System.Text.Encoding.UTF8.GetBytes(chave); aes.BlockSize = 128; aes.IV = System.Text.Encoding.UTF8.GetBytes("6abraswa+hep&#Ac"); ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV); byte[] encrypted; // 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(texto); } encrypted = msEncrypt.ToArray(); } } return Convert.ToBase64String(encrypted); }
/// <summary> /// AES加密 /// </summary> /// <param name="data"></param> /// <param name="key"></param> /// <returns></returns> public static byte[] AesEncrypt(string data, byte[] key) { if (key.Length != 16) { var ex = new Exception("the length of AES ecrypted key must be 16bit."); throw ex; } byte[] result; using (SymmetricAlgorithm algorithm = new AesCryptoServiceProvider()) { algorithm.Mode = CipherMode.ECB; algorithm.Padding = PaddingMode.PKCS7; using (ICryptoTransform transform = algorithm.CreateEncryptor(key, key)) { using (MemoryStream ms = new MemoryStream()) { using (Stream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write)) { using (StreamWriter writer = new StreamWriter(cs)) { writer.Write(data); } result = ms.ToArray(); } } } } return result; }
public static string EncryptString(string message, string passphrase = null) { if (string.IsNullOrEmpty(message)) { throw new ArgumentException("message is empty!", message); } if (string.IsNullOrEmpty(passphrase)) { passphrase = ConfigurationManager.AppSettings.Get("Common.Cryptography.DefaultPassPhrase"); } // First hash the passphrase to get a 256bit key var sha = new SHA256CryptoServiceProvider(); var passphraseHash = sha.ComputeHash(Encoding.UTF8.GetBytes(passphrase)); var aes = new AesCryptoServiceProvider { KeySize = 256, Key = passphraseHash }; var memoryStream = new MemoryStream(); var cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write); using (var writer = new StreamWriter(cryptoStream, Encoding.UTF8)) { writer.Write(message); } var results = memoryStream.ToArray(); var finalArray = new byte[aes.IV.Length + results.Length]; Array.Copy(aes.IV, 0, finalArray, 0, aes.IV.Length); Array.Copy(results, 0, finalArray, aes.IV.Length, results.Length); return HttpServerUtility.UrlTokenEncode(finalArray); }
/// <summary> /// Encrypt a message using AES in CBC (cipher-block chaining) mode. /// </summary> /// <param name="plaintext">The message (plaintext) to encrypt</param> /// <param name="key">An AES key</param> /// <param name="iv">The IV to use or null to use a 0 IV</param> /// <param name="addHmac">When set, a SHA256-based HMAC (HMAC256) of 32 bytes using the same key is added to the plaintext /// before it is encrypted.</param> /// <returns>The ciphertext derived by encrypting the orignal message using AES in CBC mode</returns> public static byte[] EncryptAesCbc(byte[] plaintext, byte[] key, byte[] iv = null, bool addHmac = false) { using (AesCryptoServiceProvider aes = new AesCryptoServiceProvider()) { aes.Key = key; if (iv == null) iv = NullIv; aes.Mode = CipherMode.CBC; aes.IV = iv; // Encrypt the message with the key using CBC and InitializationVector=0 byte[] cipherText; using (System.IO.MemoryStream ciphertext = new System.IO.MemoryStream()) { using (CryptoStream cs = new CryptoStream(ciphertext, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(plaintext, 0, plaintext.Length); if (addHmac) { byte[] hmac = new HMACSHA256(key).ComputeHash(plaintext); cs.Write(hmac, 0, hmac.Length); } cs.Flush(); } cipherText = ciphertext.ToArray(); } return cipherText; } }
private async static Task<byte[]> AliceSendsData(string message) { Console.WriteLine("Alice send message {0}", message); byte[] rawData = Encoding.UTF8.GetBytes(message); byte[] encryptedData = null; using(var aliceAlgo = new ECDiffieHellmanCng(aliceKey)) { using(CngKey bobPubKey = CngKey.Import(bobPubKeyBlob, CngKeyBlobFormat.GenericPublicBlob)) { byte[] symmKey = aliceAlgo.DeriveKeyMaterial(bobPubKey); Console.WriteLine("Alice create this symm key with Bobs public key information : {0}", Convert.ToBase64String(symmKey)); using(var aes = new AesCryptoServiceProvider()) { aes.Key = symmKey; aes.GenerateIV(); using(ICryptoTransform encryptor = aes.CreateEncryptor()) { using(MemoryStream ms = new MemoryStream()) { var cs = new CryptoStream(ms, encryptor,CryptoStreamMode.Write); await ms.WriteAsync(aes.IV, 0, aes.IV.Length); cs.Write(rawData, 0, rawData.Length); cs.Close(); encryptedData = ms.ToArray(); } } aes.Clear(); } } } Console.WriteLine("Alice message is encrypted : {0}", Convert.ToBase64String(encryptedData)); return encryptedData; }
/// <summary> /// AES加密 /// </summary> /// <param name="str">待加密字符串</param> /// <returns>加密后字符串</returns> public static string AesEncrypt(string str) { try { string key = AES_KEY; //分组加密算法 AesCryptoServiceProvider aes = new AesCryptoServiceProvider(); byte[] inputByteArray = Encoding.UTF8.GetBytes(str);//得到需要加密的字节数组 //设置密钥及密钥向量 aes.Key = Encoding.UTF8.GetBytes(key); //aes.IV = Encoding.UTF8.GetBytes(key); aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; byte[] cipherBytes = null; using (MemoryStream ms = new MemoryStream()) { using (CryptoStream cs = new CryptoStream(ms, aes.CreateEncryptor(), CryptoStreamMode.Write)) { cs.Write(inputByteArray, 0, inputByteArray.Length); cs.FlushFinalBlock(); cipherBytes = ms.ToArray();//得到加密后的字节数组 cs.Close(); ms.Close(); } } return Convert.ToBase64String(cipherBytes); } catch { } return str; }
byte[] Transform(byte[] dataBytes, byte[] passwordBytes, bool encrypt) { /// <summary>Encrypt by using AES-256 algorithm.</summary> // Create an instance of the AES class. var cipher = new System.Security.Cryptography.AesCryptoServiceProvider(); // Calculate salt to make it harder to guess key by using a dictionary attack. var hmac = new System.Security.Cryptography.HMACSHA1(passwordBytes); var salt = hmac.ComputeHash(passwordBytes); // Generate Secret Key from the password and salt. // Note: Set number of iterations to 10 in order for JavaScript example to work faster. var secretKey = new System.Security.Cryptography.Rfc2898DeriveBytes(passwordBytes, salt, 10); // Create a encryptor from the existing SecretKey bytes by using // 32 bytes (256 bits) for the secret key and // 16 bytes (128 bits) for the initialization vector (IV). var key = secretKey.GetBytes(32); var iv = secretKey.GetBytes(16); // Get cryptor as System.Security.Cryptography.ICryptoTransform class. var cryptor = encrypt ? cipher.CreateEncryptor(key, iv) : cipher.CreateDecryptor(key, iv); // Create new Input. var inputBuffer = new byte[dataBytes.Length]; // Copy data bytes to input buffer. System.Buffer.BlockCopy(dataBytes, 0, inputBuffer, 0, inputBuffer.Length); // Create a MemoryStream to hold the output bytes. var stream = new System.IO.MemoryStream(); // Create a CryptoStream through which we are going to be processing our data. var mode = System.Security.Cryptography.CryptoStreamMode.Write; var cryptoStream = new System.Security.Cryptography.CryptoStream(stream, cryptor, mode); // Start the crypting process. cryptoStream.Write(inputBuffer, 0, inputBuffer.Length); // Finish crypting. cryptoStream.FlushFinalBlock(); // Convert data from a memoryStream into a byte array. var outputBuffer = stream.ToArray(); // Close both streams. stream.Close(); cryptoStream.Close(); return(outputBuffer); }
/// <summary> /// 加密 /// </summary> /// <param name="plainBytes">明文字节数组</param> /// <returns>返回密文字节数组</returns> public byte[] Encrypt(byte[] plainBytes) { var aes = new System.Security.Cryptography.AesCryptoServiceProvider(); aes.Mode = this.CipherMode; aes.Padding = this.PaddingMode; aes.Key = GetKeyBytes(); if (aes.Mode == CipherMode.CBC && IV == null) { IV = initIV(keyBytes.Length); } if (IV != null) { aes.IV = IV; } var encryptor = aes.CreateEncryptor(); var bResult = encryptor.TransformFinalBlock(plainBytes, 0, plainBytes.Length); return(bResult); }
static public string AesLoginDynamicKey = @"d_&^t"; // 5 /// <summary> /// 문자열을 AES로 암호화 한다 /// </summary> public static string Encrypt(string dynamincKey, string text) { var comleteAesKey = dynamincKey.Substring(0, 5) + AesKey; System.Security.Cryptography.AesCryptoServiceProvider aes = new System.Security.Cryptography.AesCryptoServiceProvider(); aes.BlockSize = 128; aes.KeySize = 128; aes.IV = Encoding.UTF8.GetBytes(AesIV); aes.Key = Encoding.UTF8.GetBytes(comleteAesKey); aes.Mode = CipherMode.CBC; aes.Padding = PaddingMode.PKCS7; // 문자열을 바이트형 배열로 변환 byte[] src = Encoding.Unicode.GetBytes(text); // 암호화 한다 using (ICryptoTransform encrypt = aes.CreateEncryptor()) { byte[] dest = encrypt.TransformFinalBlock(src, 0, src.Length); // 바이트형 배열에서 Base64형식의 문자열로 변환 return(Convert.ToBase64String(dest)); } }