Uso del cifrado AES en C#

Question

Parece que no puedo encontrar un buen ejemplo de uso del cifrado AES de 128 bits.

¿Alguien tiene algún código de muestra?

Answer 1

Si lo que desea es utilizar el proveedor integrado de cripto RijndaelManaged, revisa el siguiente artículo de ayuda (que también tiene una muestra simple código):

http://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged.aspx

Y justo a Si necesita la muestra con prisa, aquí está en toda su gloria plagiada:

using System; 
using System.IO; 
using System.Security.Cryptography; 

namespace RijndaelManaged_Example 
{ 
    class RijndaelExample 
    { 
     public static void Main() 
     { 
      try 
      { 

       string original = "Here is some data to encrypt!"; 

       // Create a new instance of the RijndaelManaged 
       // class. This generates a new key and initialization 
       // vector (IV). 
       using (RijndaelManaged myRijndael = new RijndaelManaged()) 
       { 

        myRijndael.GenerateKey(); 
        myRijndael.GenerateIV(); 
        // Encrypt the string to an array of bytes. 
        byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV); 

        // Decrypt the bytes to a string. 
        string roundtrip = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV); 

        //Display the original data and the decrypted data. 
        Console.WriteLine("Original: {0}", original); 
        Console.WriteLine("Round Trip: {0}", roundtrip); 
       } 

      } 
      catch (Exception e) 
      { 
       Console.WriteLine("Error: {0}", e.Message); 
      } 
     } 
     static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV) 
     { 
      // Check arguments. 
      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("IV"); 
      byte[] encrypted; 
      // Create an RijndaelManaged object 
      // with the specified key and IV. 
      using (RijndaelManaged rijAlg = new RijndaelManaged()) 
      { 
       rijAlg.Key = Key; 
       rijAlg.IV = IV; 

       // Create a decryptor to perform the stream transform. 
       ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.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); 
         } 
         encrypted = msEncrypt.ToArray(); 
        } 
       } 
      } 


      // Return the encrypted bytes from the memory stream. 
      return encrypted; 

     } 

     static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV) 
     { 
      // Check arguments. 
      if (cipherText == null || cipherText.Length <= 0) 
       throw new ArgumentNullException("cipherText"); 
      if (Key == null || Key.Length <= 0) 
       throw new ArgumentNullException("Key"); 
      if (IV == null || IV.Length <= 0) 
       throw new ArgumentNullException("IV"); 

      // Declare the string used to hold 
      // the decrypted text. 
      string plaintext = null; 

      // Create an RijndaelManaged object 
      // with the specified key and IV. 
      using (RijndaelManaged rijAlg = new RijndaelManaged()) 
      { 
       rijAlg.Key = Key; 
       rijAlg.IV = IV; 

       // Create a decrytor to perform the stream transform. 
       ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV); 

       // Create the streams used for decryption. 
       using (MemoryStream msDecrypt = new MemoryStream(cipherText)) 
       { 
        using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) 
        { 
         using (StreamReader srDecrypt = new StreamReader(csDecrypt)) 
         { 

          // Read the decrypted bytes from the decrypting stream 
          // and place them in a string. 
          plaintext = srDecrypt.ReadToEnd(); 
         } 
        } 
       } 

      } 

      return plaintext; 

     } 
    } 
} 

Answer 2

¿Usando AES o implementando AES? Para usar AES, existe la clase System.Security.Cryptography.RijndaelManaged.

Answer 3

Para obtener un ejemplo más completo que realiza la derivación de clave además del cifrado AES, consulte la respuesta y los enlaces publicados en Getting AES encryption to work across Javascript and C#.

EDITAR
una nota al margen: Javascript Cryptography considered harmful. vale la pena leer.

Answer 4

Mire muestra aquí ..

http://msdn.microsoft.com/en-us/library/system.security.cryptography.rijndaelmanaged(v=VS.100).aspx#Y2262

El ejemplo en MSDN no se ejecuta normalmente (se produce un error) porque no hay ningún valor inicial de vector inicial (iv) yclave. Agregué 2 líneas de código y ahora trabajo normalmente.

Más detalles ver a continuación:

using System.Windows.Forms; 
using System; 
using System.Text; 
using System.IO; 
using System.Security.Cryptography; 

namespace AES_TESTER 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     private void Form1_Load(object sender, EventArgs e) 
     { 
      try 
      { 

      string original = "Here is some data to encrypt!"; 
      MessageBox.Show("Original: " + original); 

      // Create a new instance of the RijndaelManaged 
      // class. This generates a new key and initialization 
      // vector (IV). 
      using (RijndaelManaged myRijndael = new RijndaelManaged()) 
      { 
       myRijndael.GenerateKey(); 
       myRijndael.GenerateIV(); 

       // Encrypt the string to an array of bytes. 
       byte[] encrypted = EncryptStringToBytes(original, myRijndael.Key, myRijndael.IV); 

       StringBuilder s = new StringBuilder(); 
       foreach (byte item in encrypted) 
       { 
        s.Append(item.ToString("X2") + " "); 
       } 
       MessageBox.Show("Encrypted: " + s); 

       // Decrypt the bytes to a string. 
       string decrypted = DecryptStringFromBytes(encrypted, myRijndael.Key, myRijndael.IV); 

       //Display the original data and the decrypted data. 
       MessageBox.Show("Decrypted: " + decrypted); 
      } 

     } 
     catch (Exception ex) 
     { 
      MessageBox.Show("Error: {0}", ex.Message); 
     } 
    } 

    static byte[] EncryptStringToBytes(string plainText, byte[] Key, byte[] IV) 
    { 
     // Check arguments. 
     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("Key"); 
     byte[] encrypted; 
     // Create an RijndaelManaged object 
     // with the specified key and IV. 
     using (RijndaelManaged rijAlg = new RijndaelManaged()) 
     { 
      rijAlg.Key = Key; 
      rijAlg.IV = IV; 
      rijAlg.Mode = CipherMode.CBC; 
      rijAlg.Padding = PaddingMode.Zeros; 

      // Create a decrytor to perform the stream transform. 
      ICryptoTransform encryptor = rijAlg.CreateEncryptor(rijAlg.Key, rijAlg.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); 
        } 
        encrypted = msEncrypt.ToArray(); 
       } 
      } 
     } 


     // Return the encrypted bytes from the memory stream. 
     return encrypted; 

    } 

    static string DecryptStringFromBytes(byte[] cipherText, byte[] Key, byte[] IV) 
    { 
     // Check arguments. 
     if (cipherText == null || cipherText.Length <= 0) 
      throw new ArgumentNullException("cipherText"); 
     if (Key == null || Key.Length <= 0) 
      throw new ArgumentNullException("Key"); 
     if (IV == null || IV.Length <= 0) 
      throw new ArgumentNullException("Key"); 

     // Declare the string used to hold 
     // the decrypted text. 
     string plaintext = null; 

     // Create an RijndaelManaged object 
     // with the specified key and IV. 
     using (RijndaelManaged rijAlg = new RijndaelManaged()) 
     { 
      rijAlg.Key = Key; 
      rijAlg.IV = IV; 
      rijAlg.Mode = CipherMode.CBC; 
      rijAlg.Padding = PaddingMode.Zeros; 

      // Create a decrytor to perform the stream transform. 
      ICryptoTransform decryptor = rijAlg.CreateDecryptor(rijAlg.Key, rijAlg.IV); 

      // Create the streams used for decryption. 
      using (MemoryStream msDecrypt = new MemoryStream(cipherText)) 
      { 
       using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read)) 
       { 
        using (StreamReader srDecrypt = new StreamReader(csDecrypt)) 
        { 

         // Read the decrypted bytes from the decrypting stream 
         // and place them in a string. 
         plaintext = srDecrypt.ReadToEnd(); 
        } 
       } 
      } 

     } 

     return plaintext; 
    } 
    } 
} 

Answer 5

probar este código, que puede resultar útil.
1.Create Nueva C# proyecto y agregue el código siguiente a Form1:

using System; 
using System.Windows.Forms; 
using System.Security.Cryptography; 

namespace ExampleCrypto 
{ 
    public partial class Form1 : Form 
    { 
     public Form1() 
     { 
      InitializeComponent(); 
     } 

     private void Form1_Load(object sender, EventArgs e) 
     { 
      string strOriginalData = string.Empty; 
      string strEncryptedData = string.Empty; 
      string strDecryptedData = string.Empty; 

      strOriginalData = "this is original data 1234567890"; // your original data in here 
      MessageBox.Show("ORIGINAL DATA:\r\n" + strOriginalData); 

      clsCrypto aes = new clsCrypto(); 
      aes.IV = "this is your IV";  // your IV 
      aes.KEY = "this is your KEY"; // your KEY  
      strEncryptedData = aes.Encrypt(strOriginalData, CipherMode.CBC); // your cipher mode 
      MessageBox.Show("ENCRYPTED DATA:\r\n" + strEncryptedData); 

      strDecryptedData = aes.Decrypt(strEncryptedData, CipherMode.CBC); 
      MessageBox.Show("DECRYPTED DATA:\r\n" + strDecryptedData); 
     } 

    } 
} 

2.Crear clsCrypto.cs y copiar y pegar siguiente código en su clase y ejecutar su código. Usé MD5 para generar el Vector Inicial (IV) y la CLAVE de AES.

using System; 
using System.Security.Cryptography; 
using System.Text; 
using System.Windows.Forms; 
using System.IO; 
using System.Runtime.Remoting.Metadata.W3cXsd2001; 

namespace ExampleCrypto 
{ 
    public class clsCrypto 
    { 
     private string _KEY = string.Empty; 
     protected internal string KEY 
     { 
      get 
      { 
       return _KEY; 
      } 
      set 
      { 
       if (!string.IsNullOrEmpty(value)) 
       { 
        _KEY = value; 
       } 
      } 
     } 

     private string _IV = string.Empty; 
     protected internal string IV 
     { 
      get 
      { 
       return _IV; 
      } 
      set 
      { 
       if (!string.IsNullOrEmpty(value)) 
       { 
        _IV = value; 
       } 
      } 
     } 

     private string CalcMD5(string strInput) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        StringBuilder strHex = new StringBuilder(); 
        using (MD5 md5 = MD5.Create()) 
        { 
         byte[] bytArText = Encoding.Default.GetBytes(strInput); 
         byte[] bytArHash = md5.ComputeHash(bytArText); 
         for (int i = 0; i < bytArHash.Length; i++) 
         { 
          strHex.Append(bytArHash[i].ToString("X2")); 
         } 
         strOutput = strHex.ToString(); 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

     private byte[] GetBytesFromHexString(string strInput) 
     { 
      byte[] bytArOutput = new byte[] { }; 
      if ((!string.IsNullOrEmpty(strInput)) && strInput.Length % 2 == 0) 
      { 
       SoapHexBinary hexBinary = null; 
       try 
       { 
        hexBinary = SoapHexBinary.Parse(strInput); 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
       bytArOutput = hexBinary.Value; 
      } 
      return bytArOutput; 
     } 

     private byte[] GenerateIV() 
     { 
      byte[] bytArOutput = new byte[] { }; 
      try 
      { 
       string strIV = CalcMD5(IV); 
       bytArOutput = GetBytesFromHexString(strIV); 
      } 
      catch (Exception ex) 
      { 
       MessageBox.Show(ex.Message); 
      } 
      return bytArOutput; 
     } 

     private byte[] GenerateKey() 
     { 
      byte[] bytArOutput = new byte[] { }; 
      try 
      { 
       string strKey = CalcMD5(KEY); 
       bytArOutput = GetBytesFromHexString(strKey); 
      } 
      catch (Exception ex) 
      { 
       MessageBox.Show(ex.Message); 
      } 
      return bytArOutput; 
     } 

     protected internal string Encrypt(string strInput, CipherMode cipherMode) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        byte[] bytePlainText = Encoding.Default.GetBytes(strInput); 
        using (RijndaelManaged rijManaged = new RijndaelManaged()) 
        { 
         rijManaged.Mode = cipherMode; 
         rijManaged.BlockSize = 128; 
         rijManaged.KeySize = 128; 
         rijManaged.IV = GenerateIV(); 
         rijManaged.Key = GenerateKey(); 
         rijManaged.Padding = PaddingMode.Zeros; 
         ICryptoTransform icpoTransform = rijManaged.CreateEncryptor(rijManaged.Key, rijManaged.IV); 
         using (MemoryStream memStream = new MemoryStream()) 
         { 
          using (CryptoStream cpoStream = new CryptoStream(memStream, icpoTransform, CryptoStreamMode.Write)) 
          { 
           cpoStream.Write(bytePlainText, 0, bytePlainText.Length); 
           cpoStream.FlushFinalBlock(); 
          } 
          strOutput = Encoding.Default.GetString(memStream.ToArray()); 
         } 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

     protected internal string Decrypt(string strInput, CipherMode cipherMode) 
     { 
      string strOutput = string.Empty; 
      if (!string.IsNullOrEmpty(strInput)) 
      { 
       try 
       { 
        byte[] byteCipherText = Encoding.Default.GetBytes(strInput); 
        byte[] byteBuffer = new byte[strInput.Length]; 
        using (RijndaelManaged rijManaged = new RijndaelManaged()) 
        { 
         rijManaged.Mode = cipherMode; 
         rijManaged.BlockSize = 128; 
         rijManaged.KeySize = 128; 
         rijManaged.IV = GenerateIV(); 
         rijManaged.Key = GenerateKey(); 
         rijManaged.Padding = PaddingMode.Zeros; 
         ICryptoTransform icpoTransform = rijManaged.CreateDecryptor(rijManaged.Key, rijManaged.IV); 
         using (MemoryStream memStream = new MemoryStream(byteCipherText)) 
         { 
          using (CryptoStream cpoStream = new CryptoStream(memStream, icpoTransform, CryptoStreamMode.Read)) 
          { 
           cpoStream.Read(byteBuffer, 0, byteBuffer.Length); 
          } 
          strOutput = Encoding.Default.GetString(byteBuffer); 
         } 
        } 
       } 
       catch (Exception ex) 
       { 
        MessageBox.Show(ex.Message); 
       } 
      } 
      return strOutput; 
     } 

    } 
} 

Answer 6

recientemente he tenido que topan con esto otra vez en mi propio proyecto - y quería compartir el código algo más sencilla que he estado usando, ya que esta cuestión y la serie de respuestas seguía apareciendo en mi búsquedas.

No voy a entrar en los problemas de seguridad alrededor de la frecuencia para actualizar cosas como su Sal y vector de inicialización - eso es un tema para un foro de seguridad, y hay algunos grandes recursos hacia fuera allí para ver a. Esto es simplemente un bloque de código para implementar AesManaged en C#.

using System; 
using System.IO; 
using System.Security.Cryptography; 
using System.Text; 

namespace Your.Namespace.Security { 
    public static class Cryptography { 
     #region Settings 

     private static int _iterations = 2; 
     private static int _keySize = 256; 

     private static string _hash  = "SHA1"; 
     private static string _salt  = "aselrias38490a32"; // Random 
     private static string _vector = "8947az34awl34kjq"; // Random 

     #endregion 

     public static string Encrypt(string value, string password) { 
      return Encrypt<AesManaged>(value, password); 
     } 
     public static string Encrypt<T>(string value, string password) 
       where T : SymmetricAlgorithm, new() { 
      byte[] vectorBytes = GetBytes<ASCIIEncoding>(_vector); 
      byte[] saltBytes = GetBytes<ASCIIEncoding>(_salt); 
      byte[] valueBytes = GetBytes<UTF8Encoding>(value); 

      byte[] encrypted; 
      using (T cipher = new T()) { 
       PasswordDeriveBytes _passwordBytes = 
        new PasswordDeriveBytes(password, saltBytes, _hash, _iterations); 
       byte[] keyBytes = _passwordBytes.GetBytes(_keySize/8); 

       cipher.Mode = CipherMode.CBC; 

       using (ICryptoTransform encryptor = cipher.CreateEncryptor(keyBytes, vectorBytes)) { 
        using (MemoryStream to = new MemoryStream()) { 
         using (CryptoStream writer = new CryptoStream(to, encryptor, CryptoStreamMode.Write)) { 
          writer.Write(valueBytes, 0, valueBytes.Length); 
          writer.FlushFinalBlock(); 
          encrypted = to.ToArray(); 
         } 
        } 
       } 
       cipher.Clear(); 
      } 
      return Convert.ToBase64String(encrypted); 
     } 

     public static string Decrypt(string value, string password) { 
      return Decrypt<AesManaged>(value, password); 
     } 
     public static string Decrypt<T>(string value, string password) where T : SymmetricAlgorithm, new() { 
      byte[] vectorBytes = GetBytes<ASCIIEncoding>(_vector); 
      byte[] saltBytes = GetBytes<ASCIIEncoding>(_salt); 
      byte[] valueBytes = Convert.FromBase64String(value); 

      byte[] decrypted; 
      int decryptedByteCount = 0; 

      using (T cipher = new T()) { 
       PasswordDeriveBytes _passwordBytes = new PasswordDeriveBytes(password, saltBytes, _hash, _iterations); 
       byte[] keyBytes = _passwordBytes.GetBytes(_keySize/8); 

       cipher.Mode = CipherMode.CBC; 

       try { 
        using (ICryptoTransform decryptor = cipher.CreateDecryptor(keyBytes, vectorBytes)) { 
         using (MemoryStream from = new MemoryStream(valueBytes)) { 
          using (CryptoStream reader = new CryptoStream(from, decryptor, CryptoStreamMode.Read)) { 
           decrypted = new byte[valueBytes.Length]; 
           decryptedByteCount = reader.Read(decrypted, 0, decrypted.Length); 
          } 
         } 
        } 
       } catch (Exception ex) { 
        return String.Empty; 
       } 

       cipher.Clear(); 
      } 
      return Encoding.UTF8.GetString(decrypted, 0, decryptedByteCount); 
     } 

    } 
} 

El código es muy simple de usar.Es, literalmente, sólo requiere lo siguiente:

string encrypted = Cryptography.Encrypt(data, "testpass"); 
string decrypted = Cryptography.Decrypt(encrypted, "testpass"); 

Por defecto, la aplicación utiliza AesManaged - pero en realidad se podría insertar también cualquier otra SymmetricAlgorithm. Una lista de los herederos SymmetricAlgorithm disponibles para .NET 4.5 se puede encontrar en:

http://msdn.microsoft.com/en-us/library/system.security.cryptography.symmetricalgorithm.aspx

En el momento de este post, la lista actual incluye:

• AesManaged
• RijndaelManaged
• DESCryptoServiceProvider
• RC2CryptoServiceProvider
• TripleDESCryptoServiceProvider

Para utilizar RijndaelManaged con el código anterior, como ejemplo, se debería utilizar:

string encrypted = Cryptography.Encrypt<RijndaelManaged>(dataToEncrypt, password); 
string decrypted = Cryptography.Decrypt<RijndaelManaged>(encrypted, password); 

espero que esto sea útil a alguien por ahí.

Answer 7

Se puede utilizar la contraseña de la caja de texto como clave ... Con este código se puede cifrar/descifrar el texto, imagen, documento de word, pdf ....

public class Rijndael 
{ 
    private byte[] key; 
    private readonly byte[] vector = { 255, 64, 191, 111, 23, 3, 113, 119, 231, 121, 252, 112, 79, 32, 114, 156 }; 

    ICryptoTransform EnkValue, DekValue; 

    public Rijndael(byte[] key) 
    { 
     this.key = key; 
     RijndaelManaged rm = new RijndaelManaged(); 
     rm.Padding = PaddingMode.PKCS7; 
     EnkValue = rm.CreateEncryptor(key, vector); 
     DekValue = rm.CreateDecryptor(key, vector); 
    } 

    public byte[] Encrypt(byte[] byte) 
    { 

     byte[] enkByte= byte; 
     byte[] enkNewByte; 
     using (MemoryStream ms = new MemoryStream()) 
     { 
      using (CryptoStream cs = new CryptoStream(ms, EnkValue, CryptoStreamMode.Write)) 
      { 
       cs.Write(enkByte, 0, enkByte.Length); 
       cs.FlushFinalBlock(); 

       ms.Position = 0; 
       enkNewByte= new byte[ms.Length]; 
       ms.Read(enkNewByte, 0, enkNewByte.Length); 
      } 
     } 
     return enkNeyByte; 
    } 

    public byte[] Dekrypt(byte[] enkByte) 
    { 
     byte[] dekByte; 
     using (MemoryStream ms = new MemoryStream()) 
     { 
      using (CryptoStream cs = new CryptoStream(ms, DekValue, CryptoStreamMode.Write)) 
      { 
       cs.Write(enkByte, 0, enkByte.Length); 
       cs.FlushFinalBlock(); 

       ms.Position = 0; 
       dekByte= new byte[ms.Length]; 
       ms.Read(dekByte, 0, dekByte.Length); 
      } 
     } 
     return dekByte; 
    } 
} 

contraseña Convertir de cuadro de texto para matriz de bytes ...

private byte[] ConvertPasswordToByte(string password) 
    { 
     byte[] key = new byte[32]; 
     for (int i = 0; i < passwprd.Length; i++) 
     { 
      key[i] = Convert.ToByte(passwprd[i]); 
     } 
     return key; 
    } 

Answer 8

//Code to encrypt Data : 
public byte[] encryptdata(byte[] bytearraytoencrypt, string key, string iv) 
     { 
      AesCryptoServiceProvider dataencrypt = new AesCryptoServiceProvider(); 
      //Block size : Gets or sets the block size, in bits, of the cryptographic operation. 
      dataencrypt.BlockSize = 128; 
      //KeySize: Gets or sets the size, in bits, of the secret key 
      dataencrypt.KeySize = 128; 
      //Key: Gets or sets the symmetric key that is used for encryption and decryption. 
      dataencrypt.Key = System.Text.Encoding.UTF8.GetBytes(key); 
      //IV : Gets or sets the initialization vector (IV) for the symmetric algorithm 
      dataencrypt.IV = System.Text.Encoding.UTF8.GetBytes(iv); 
      //Padding: Gets or sets the padding mode used in the symmetric algorithm 
      dataencrypt.Padding = PaddingMode.PKCS7; 
      //Mode: Gets or sets the mode for operation of the symmetric algorithm 
      dataencrypt.Mode = CipherMode.CBC; 
      //Creates a symmetric AES encryptor object using the current key and initialization vector (IV). 
      ICryptoTransform crypto1 = dataencrypt.CreateEncryptor(dataencrypt.Key, dataencrypt.IV); 
      //TransformFinalBlock is a special function for transforming the last block or a partial block in the stream. 
      //It returns a new array that contains the remaining transformed bytes. A new array is returned, because the amount of 
      //information returned at the end might be larger than a single block when padding is added. 
      byte[] encrypteddata = crypto1.TransformFinalBlock(bytearraytoencrypt, 0, bytearraytoencrypt.Length); 
      crypto1.Dispose(); 
      //return the encrypted data 
      return encrypteddata; 
     } 

//code to decrypt data 
    private byte[] decryptdata(byte[] bytearraytodecrypt, string key, string iv) 
    { 

     AesCryptoServiceProvider keydecrypt = new AesCryptoServiceProvider(); 
     keydecrypt.BlockSize = 128; 
     keydecrypt.KeySize = 128; 
     keydecrypt.Key = System.Text.Encoding.UTF8.GetBytes(key); 
     keydecrypt.IV = System.Text.Encoding.UTF8.GetBytes(iv); 
     keydecrypt.Padding = PaddingMode.PKCS7; 
     keydecrypt.Mode = CipherMode.CBC; 
     ICryptoTransform crypto1 = keydecrypt.CreateDecryptor(keydecrypt.Key, keydecrypt.IV); 

     byte[] returnbytearray = crypto1.TransformFinalBlock(bytearraytodecrypt, 0, bytearraytodecrypt.Length); 
     crypto1.Dispose(); 
     return returnbytearray; 
    } 

Answer 9

aquí es un código limpio y ordenado para entender AES de 256 algoritmo implementado en C# función Cifrar llamada como encryptedstring = cryptObj.Encrypt(username, "AGARAMUDHALA", "EZHUTHELLAM", "SHA1", 3, "@1B2c3D4e5F6g7H8", 256);

public class Crypt 
{ 
    public string Encrypt(string passtext, string passPhrase, string saltV, string hashstring, int Iterations, string initVect, int keysize) 
    { 
     string functionReturnValue = null; 
     // Convert strings into byte arrays. 
     // Let us assume that strings only contain ASCII codes. 
     // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
     // encoding. 
     byte[] initVectorBytes = null; 
     initVectorBytes = Encoding.ASCII.GetBytes(initVect); 
     byte[] saltValueBytes = null; 
     saltValueBytes = Encoding.ASCII.GetBytes(saltV); 

     // Convert our plaintext into a byte array. 
     // Let us assume that plaintext contains UTF8-encoded characters. 
     byte[] plainTextBytes = null; 
     plainTextBytes = Encoding.UTF8.GetBytes(passtext); 
     // First, we must create a password, from which the key will be derived. 
     // This password will be generated from the specified passphrase and 
     // salt value. The password will be created using the specified hash 
     // algorithm. Password creation can be done in several iterations. 
     PasswordDeriveBytes password = default(PasswordDeriveBytes); 
     password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashstring, Iterations); 
     // Use the password to generate pseudo-random bytes for the encryption 
     // key. Specify the size of the key in bytes (instead of bits). 
     byte[] keyBytes = null; 
     keyBytes = password.GetBytes(keysize/8); 
     // Create uninitialized Rijndael encryption object. 
     RijndaelManaged symmetricKey = default(RijndaelManaged); 
     symmetricKey = new RijndaelManaged(); 

     // It is reasonable to set encryption mode to Cipher Block Chaining 
     // (CBC). Use default options for other symmetric key parameters. 
     symmetricKey.Mode = CipherMode.CBC; 
     // Generate encryptor from the existing key bytes and initialization 
     // vector. Key size will be defined based on the number of the key 
     // bytes. 
     ICryptoTransform encryptor = default(ICryptoTransform); 
     encryptor = symmetricKey.CreateEncryptor(keyBytes, initVectorBytes); 

     // Define memory stream which will be used to hold encrypted data. 
     MemoryStream memoryStream = default(MemoryStream); 
     memoryStream = new MemoryStream(); 

     // Define cryptographic stream (always use Write mode for encryption). 
     CryptoStream cryptoStream = default(CryptoStream); 
     cryptoStream = new CryptoStream(memoryStream, encryptor, CryptoStreamMode.Write); 
     // Start encrypting. 
     cryptoStream.Write(plainTextBytes, 0, plainTextBytes.Length); 

     // Finish encrypting. 
     cryptoStream.FlushFinalBlock(); 
     // Convert our encrypted data from a memory stream into a byte array. 
     byte[] cipherTextBytes = null; 
     cipherTextBytes = memoryStream.ToArray(); 

     // Close both streams. 
     memoryStream.Close(); 
     cryptoStream.Close(); 

     // Convert encrypted data into a base64-encoded string. 
     string cipherText = null; 
     cipherText = Convert.ToBase64String(cipherTextBytes); 

     functionReturnValue = cipherText; 
     return functionReturnValue; 
    } 
    public string Decrypt(string cipherText, string passPhrase, string saltValue, string hashAlgorithm, int passwordIterations, string initVector, int keySize) 
    { 
     string functionReturnValue = null; 

     // Convert strings defining encryption key characteristics into byte 
     // arrays. Let us assume that strings only contain ASCII codes. 
     // If strings include Unicode characters, use Unicode, UTF7, or UTF8 
     // encoding. 


      byte[] initVectorBytes = null; 
      initVectorBytes = Encoding.ASCII.GetBytes(initVector); 

      byte[] saltValueBytes = null; 
      saltValueBytes = Encoding.ASCII.GetBytes(saltValue); 

      // Convert our ciphertext into a byte array. 
      byte[] cipherTextBytes = null; 
      cipherTextBytes = Convert.FromBase64String(cipherText); 

      // First, we must create a password, from which the key will be 
      // derived. This password will be generated from the specified 
      // passphrase and salt value. The password will be created using 
      // the specified hash algorithm. Password creation can be done in 
      // several iterations. 
      PasswordDeriveBytes password = default(PasswordDeriveBytes); 
      password = new PasswordDeriveBytes(passPhrase, saltValueBytes, hashAlgorithm, passwordIterations); 

      // Use the password to generate pseudo-random bytes for the encryption 
      // key. Specify the size of the key in bytes (instead of bits). 
      byte[] keyBytes = null; 
      keyBytes = password.GetBytes(keySize/8); 

      // Create uninitialized Rijndael encryption object. 
      RijndaelManaged symmetricKey = default(RijndaelManaged); 
      symmetricKey = new RijndaelManaged(); 

      // It is reasonable to set encryption mode to Cipher Block Chaining 
      // (CBC). Use default options for other symmetric key parameters. 
      symmetricKey.Mode = CipherMode.CBC; 

      // Generate decryptor from the existing key bytes and initialization 
      // vector. Key size will be defined based on the number of the key 
      // bytes. 
      ICryptoTransform decryptor = default(ICryptoTransform); 
      decryptor = symmetricKey.CreateDecryptor(keyBytes, initVectorBytes); 

      // Define memory stream which will be used to hold encrypted data. 
      MemoryStream memoryStream = default(MemoryStream); 
      memoryStream = new MemoryStream(cipherTextBytes); 

      // Define memory stream which will be used to hold encrypted data. 
      CryptoStream cryptoStream = default(CryptoStream); 
      cryptoStream = new CryptoStream(memoryStream, decryptor, CryptoStreamMode.Read); 

      // Since at this point we don't know what the size of decrypted data 
      // will be, allocate the buffer long enough to hold ciphertext; 
      // plaintext is never longer than ciphertext. 
      byte[] plainTextBytes = null; 
      plainTextBytes = new byte[cipherTextBytes.Length + 1]; 

      // Start decrypting. 
      int decryptedByteCount = 0; 
      decryptedByteCount = cryptoStream.Read(plainTextBytes, 0, plainTextBytes.Length); 

      // Close both streams. 
      memoryStream.Close(); 
      cryptoStream.Close(); 

      // Convert decrypted data into a string. 
      // Let us assume that the original plaintext string was UTF8-encoded. 
      string plainText = null; 
      plainText = Encoding.UTF8.GetString(plainTextBytes, 0, decryptedByteCount); 

      // Return decrypted string. 
      functionReturnValue = plainText; 


     return functionReturnValue; 
    } 
} 

Answer 10

http://www.codeproject.com/Articles/769741/Csharp-AES-bits-Encryption-Library-with-Salt

using System.Security.Cryptography; 
using System.IO; 

public byte[] AES_Encrypt(byte[] bytesToBeEncrypted, byte[] passwordBytes) 
{ 
    byte[] encryptedBytes = null; 
    byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; 
    using (MemoryStream ms = new MemoryStream()) 
    { 
     using (RijndaelManaged AES = new RijndaelManaged()) 
     { 
      AES.KeySize = 256; 
      AES.BlockSize = 128; 
      var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000); 
      AES.Key = key.GetBytes(AES.KeySize/8); 
      AES.IV = key.GetBytes(AES.BlockSize/8); 
      AES.Mode = CipherMode.CBC; 
      using (var cs = new CryptoStream(ms, AES.CreateEncryptor(), CryptoStreamMode.Write)) 
      { 
       cs.Write(bytesToBeEncrypted, 0, bytesToBeEncrypted.Length); 
       cs.Close(); 
      } 
      encryptedBytes = ms.ToArray(); 
     } 
    } 
    return encryptedBytes; 
} 

public byte[] AES_Decrypt(byte[] bytesToBeDecrypted, byte[] passwordBytes) 
{ 
    byte[] decryptedBytes = null; 
    byte[] saltBytes = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; 
    using (MemoryStream ms = new MemoryStream()) 
    { 
     using (RijndaelManaged AES = new RijndaelManaged()) 
     { 
      AES.KeySize = 256; 
      AES.BlockSize = 128; 
      var key = new Rfc2898DeriveBytes(passwordBytes, saltBytes, 1000); 
      AES.Key = key.GetBytes(AES.KeySize/8); 
      AES.IV = key.GetBytes(AES.BlockSize/8); 
      AES.Mode = CipherMode.CBC; 
      using (var cs = new CryptoStream(ms, AES.CreateDecryptor(), CryptoStreamMode.Write)) 
      { 
       cs.Write(bytesToBeDecrypted, 0, bytesToBeDecrypted.Length); 
       cs.Close(); 
      } 
      decryptedBytes = ms.ToArray(); 
     } 
    } 
    return decryptedBytes; 
}