encypt& dcrypt, C#

Language: Layout:

//Rextester.Program.Main is the entry point for your code. Don't change it.
//Compiler version 4.0.30319.17929 for Microsoft (R) .NET Framework 4.5

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

public class RijndaelAlgorithm
{
    public static string Encrypt
    (
        string plainText,
        string passPhrase,
        string saltValue,
        string hashAlgorithm,
        int passwordIterations,
        string initVector,
        int keySize
    )
    {
        // 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 = Encoding.ASCII.GetBytes(initVector);
        byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
 
        // Convert our plaintext into a byte array.
        byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);
 
        // 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 = 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 = password.GetBytes(keySize / 8);
 
        // Create uninitialized Rijndael encryption object.
        RijndaelManaged symmetricKey = new RijndaelManaged();
        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 = symmetricKey.CreateEncryptor
        (
            keyBytes,
            initVectorBytes
        );
 
        // Define memory stream which will be used to hold encrypted data.
        MemoryStream memoryStream = new MemoryStream();
 
        // Define cryptographic stream (always use Write mode for encryption).
        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 = memoryStream.ToArray();
 
        // Close both streams.
        memoryStream.Close();
        cryptoStream.Close();
 
        // Convert encrypted data into a base64-encoded string.
        string cipherText = Convert.ToBase64String(cipherTextBytes);
 
        // Return encrypted string.
        return cipherText;
    }
 
    public static string Decrypt
    (
        string cipherText,
        string passPhrase,
        string saltValue,
        string hashAlgorithm,
        int passwordIterations,
        string initVector,
        int keySize
    )
    {
        // Convert strings defining encryption key characteristics into byte arrays. 
        byte[] initVectorBytes = Encoding.ASCII.GetBytes(initVector);
        byte[] saltValueBytes = Encoding.ASCII.GetBytes(saltValue);
 
        // Convert our ciphertext into a byte array.
        byte[] 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 = 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 = password.GetBytes(keySize / 8);
 
        // Create uninitialized Rijndael encryption object.
        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 = symmetricKey.CreateDecryptor
        (
            keyBytes,
            initVectorBytes
        );
 
        // Define memory stream which will be used to hold encrypted data.
        MemoryStream memoryStream = new MemoryStream(cipherTextBytes);
 
        // Define cryptographic stream (always use Read mode for encryption).
        CryptoStream cryptoStream = new CryptoStream
        (
            memoryStream,
            decryptor,
            CryptoStreamMode.Read
        );
        byte[] plainTextBytes = new byte[cipherTextBytes.Length];
 
        // Start decrypting.
        int 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 = Encoding.UTF8.GetString
        (
            plainTextBytes,
            0,
            decryptedByteCount
        );
 
        // Return decrypted string.   
        return plainText;
    }
}
 
/// Illustrates the use of RijndaelSimple class to encrypt and decrypt data.
 
public class RijndaelSimpleTest
{
    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main(string[] args)
    {
        //string plainText = "Welcome to csharpstar.com!";    // original plaintext
 
        Console.Write("Input the Original Plain Text : ");
        string plainText = Console.ReadLine();
 
        string passPhrase = "TestPassphrase";        // can be any string
        string saltValue = "TestSaltValue";        // can be any string
        string hashAlgorithm = "SHA256";             // can be "MD5"
        int passwordIterations = 2;                // can be any number
        string initVector = "!1A3g2D4s9K556g7"; // must be 16 bytes
        int keySize = 256;                // can be 192 or 128
 
        Console.WriteLine(String.Format("Plaintext : {0}", plainText));
 
        string cipherText = RijndaelAlgorithm.Encrypt
        (
            plainText,
            passPhrase,
            saltValue,
            hashAlgorithm,
            passwordIterations,
            initVector,
            keySize
        );
 
        Console.WriteLine(String.Format("Encrypted : {0}", cipherText));
 
        plainText = RijndaelAlgorithm.Decrypt
        (
            cipherText,
            passPhrase,
            saltValue,
            hashAlgorithm,
            passwordIterations,
            initVector,
            keySize
        );
 
        Console.WriteLine(String.Format("Decrypted : {0}", plainText));
    }
}

Show compiler warnings [ + ] Show input
absolute service time: 0,13 sec