Encriptacion Rijndael con C#

La encriptación es el proceso para volver ilegible información considera importante. La información una vez encriptada sólo puede leerse aplicándole una clave.

El Instituto Nacional de Estándares y Tecnología (NIST) anunció oficialmente Rijndael, diseñado por Joan Daemen y Vincent Rijmen, sería el nuevo estándar de cifrado avanzado.

AES (Advanced Encryption Standard) es el estándar actual de encriptación, destinados a ser utilizados por el Gobierno de los EE.UU. para proteger la información de las organizaciones (e incluso secreta y de alto secreto) . Que también se está convirtiendo en un estándar global para las comunicaciones de software y hardware que utilizan cifrado. Se trata de un sistema de cifrado de bloque que utiliza 128-bit, 192-bits o 256 bits. Rijndael es muy seguro y no tiene puntos débiles.

Framework .NET pensando en la seguridad, ofrece el namespace System.Security.Cryptography, que proporciona clases para el cifrado simétrico, asimétrico, hash, firmas digitales, certificados digitales y firmas XML.

Con el framework .Net, tenemos 4 opciones de algritmos de encriptación simétricos:
° DES
° Triple DES
° RC2
° Rijndael

Vamos con el código, tenemos principalmente 2 métodos, uno encripta y otro desencripta.

Los namespace que requerimos: using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;

El metodo principal: static void Main(string[] args)
        {
            string z_varostrTexto = "";

            string z_varostrPassPhrase    = "AquivaMiPassword";   // Puede ser cualquier texto
            string z_varostrSaltValue     = "ValorDeSalto";       // Puede ser cualquier texto
            string z_varostrHashAlgorithm = "SHA1";               // Puede ser "MD5"
            string z_varostrInitVector    = "0123456789ABCDEF";   // Debe ser de 16 bytes
            int    z_varointKeySize       = 256;                  // Puede ser 128, 192 o 256
            int    z_varointPassIteration = 2;                    // Puede ser cualquier numero

            //Encriptamos cualquier texto
            z_varostrTexto = z_metuEncrypt("Hola Mundo", z_varostrPassPhrase, z_varostrSaltValue, z_varostrHashAlgorithm, z_varointPassIteration , z_varostrInitVector, z_varointKeySize);
            Console.WriteLine(z_varostrTexto);
            //Desencriptamos el texto encriptado anterior
            Console.WriteLine(z_metuDecrypt(z_varostrTexto, z_varostrPassPhrase, z_varostrSaltValue, z_varostrHashAlgorithm, z_varointPassIteration, z_varostrInitVector, z_varointKeySize));
        }

El metodo que encripta: public static string z_metuEncrypt(string z_parstrPlainText, string z_parstrPassPhrase, string z_parstrSaltValue, string z_parstrHashAlgorithm, int z_parintPassIterations, string z_parstrInitVector, int z_parintKeySize)
        {
            // Convertir la cadena en un arreglo de bytes
            // Suponiendo que las cadenas solo contienen codigo ASCII.
            // Si las cadenas incluyen caracteres Unicode, el uso de Unicode, UTF7, o codificación UTF8.
            byte[] z_varobytInitVectorBytes = Encoding.ASCII.GetBytes(z_parstrInitVector);
            byte[] z_varobytSaltValueBytes = Encoding.ASCII.GetBytes(z_parstrSaltValue);

            // Convertir el texto en un arreglo de bytes.
            // Suponiendo que el texto contiene caracteres codificados en UTF8.
            byte[] z_varobytPlainTextBytes = Encoding.UTF8.GetBytes(z_parstrPlainText);

            // En primer lugar, debemos crear una contraseña, la clave a partir de la cual se derivan.
            // Esta contraseña se generarán a partir de la contraseña que se especifica y el salt value.
            // La contraseña será creada utilizando el algoritmo hash especificado.
            // La creación de la contraseña se puede hacer de varias iteraciones.
            PasswordDeriveBytes z_varocioPassword = new PasswordDeriveBytes(z_parstrPassPhrase, z_varobytSaltValueBytes, z_parstrHashAlgorithm, z_parintPassIterations);

            // Utilice la contraseña para generar bytes para la clave de cifrado pseudo aleatorias.
            // Especificar el tamaño de la clave en bytes (en lugar de bits).
            byte[] z_varobytKeyBytes = z_varocioPassword.GetBytes(z_parintKeySize / 8);

            // Instanciar el objeto Rijndael
            RijndaelManaged z_varocioSymmetricKey = new RijndaelManaged();

            // Es razonable para establecer el modo de cifrado Cipher Block Chaining (CBC).
            // Utilice las opciones por defecto para los demás parámetros de claves simétricas.
            z_varocioSymmetricKey.Mode = CipherMode.CBC;

            // Generar el encryptor para la llave de bytes existente e inicizlizar el vector.
            // Tamaño de clave se definirá en función del número de la clave de bytes.
            ICryptoTransform z_varocioEncryptor = z_varocioSymmetricKey.CreateEncryptor(z_varobytKeyBytes, z_varobytInitVectorBytes);

            // Instancia el stream de memoria que se utiliza para mantener los datos cifrados.
            MemoryStream z_varocioMemoryStream = new MemoryStream();

            // Instancia el cryptographic stream (utilizar siempre el modo de escritura para el cifrado).
            CryptoStream z_varocioCryptoStream = new CryptoStream(z_varocioMemoryStream, z_varocioEncryptor, CryptoStreamMode.Write);
            // Inicia la encriptacion
            z_varocioCryptoStream.Write(z_varobytPlainTextBytes, 0, z_varobytPlainTextBytes.Length);

            // Termina la encriptacion
            z_varocioCryptoStream.FlushFinalBlock();

            // Convertir los datos cifrados del stream de memoria en un array de bytes.
            byte[] z_varobytCipherTextBytes = z_varocioMemoryStream.ToArray();

            // Cierre de ambos streams.
            z_varocioMemoryStream.Close();
            z_varocioCryptoStream.Close();

            // Convertir datos codificados en una cadena codificada en base64.
            string z_varostrCipherText = Convert.ToBase64String(z_varobytCipherTextBytes);

            // Retorno del texto cifrado
            return z_varostrCipherText;
        }

El metodo que desencripta: public static string z_metuDecrypt(string z_parstrCipherText, string z_parstrPassPhrase, string z_parstrSaltValue, string z_parstrHashAlgorithm, int z_parintPassIterations, string z_parstrInitVector, int z_parintKeySize)
        {
            // Convertir la cadena en arreglo de bytes.
            // Vamos a suponer que las cadenas que sólo contienen código ASCII.
            byte[] z_varobytInitVectorBytes = Encoding.ASCII.GetBytes(z_parstrInitVector);
            byte[] z_varobytSaltValueBytes = Encoding.ASCII.GetBytes(z_parstrSaltValue);

            // Convertir el texto cifrado en un arreglo de bytes
            byte[] z_varobytCipherTextBytes = Convert.FromBase64String(z_parstrCipherText);

            // Primero, debemos crear una contraseña, y la clave a partir de la cual se derivan.
            // La contraseña se generarán a partir del passphrase y el salt value.
            // La contraseña será creada utilizando el algoritmo hash especificado.
            // La creación de la contraseña se puede hacer de varias iteraciones.
            PasswordDeriveBytes z_varocioPassword = new PasswordDeriveBytes(z_parstrPassPhrase, z_varobytSaltValueBytes, z_parstrHashAlgorithm, z_parintPassIterations);

            // Usa el password para generar bytes pseudo aleatorios
            // Indica el tamaño de la llave de bytes (en lugar de bits).
            byte[] z_varobytKeyBytes = z_varocioPassword.GetBytes(z_parintKeySize / 8);

            // Instancia del objeto Rijndael.
            RijndaelManaged z_varocioSymmetricKey = new RijndaelManaged();

            // Es razonable para establecer el modo de cifrado Cipher Block Chaining (CBC).
            // Utilice las opciones por defecto para los demás parámetros de claves simétricas.
            z_varocioSymmetricKey.Mode = CipherMode.CBC;

            // Generar el encryptor para la llave de bytes existente e inicizlizar el vector.
            // Tamaño de clave se definirá en función del número de la clave de bytes.
            ICryptoTransform z_varocioDecryptor = z_varocioSymmetricKey.CreateDecryptor(z_varobytKeyBytes, z_varobytInitVectorBytes);

            // Instancia el stream de memoria que se utiliza para mantener los datos cifrados.
            MemoryStream z_varocioMemoryStream = new MemoryStream(z_varobytCipherTextBytes);

            // Instancia el cryptographic stream (utilizar siempre el modo de lectura para el descifrado).
            CryptoStream z_varocioCryptoStream = new CryptoStream(z_varocioMemoryStream, z_varocioDecryptor, CryptoStreamMode.Read);

            // Dado que en este momento no sabemos cuál es el tamaño del texto descifrado,
            byte[] z_varobytPlainTextBytes = new byte[z_varobytCipherTextBytes.Length];

            // Inicia desencriptacion.
            int z_varointDecryptedByteCount = z_varocioCryptoStream.Read(z_varobytPlainTextBytes, 0, z_varobytPlainTextBytes.Length);

            // Cierre de ambos streams.
            z_varocioMemoryStream.Close();
            z_varocioCryptoStream.Close();

            // Convierte el dato desencriptado a un string.
            // Suponemos que el texto original se encuentra en UTF8.
            string z_varostrPlainText = Encoding.UTF8.GetString(z_varobytPlainTextBytes, 0, z_varointDecryptedByteCount);

            // Regreso del texto descifrado.
            return z_varostrPlainText;
        }

El código: Click Aqui

Ailas........