Use Rijndael to Encrypt and Decrypt

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

namespace  EncryptAndDecrypt
... {
    
    class Class1
    ...{
        
        static void Main(string[] args)
        ...{
            string str = "Guo 松";
            string psw = "  ";
            Console.WriteLine("before encrypt str = " + str);
            str = EncDec.Encrypt(str,psw);
            Console.WriteLine("after encrypt str = " + str);
            str = EncDec.Decrypt(str,psw);
            Console.WriteLine("after Decrypt str = " + str);
        }
    }
    public class EncDec
    ...{
        public static byte[] Encrypt(byte[] clearData,byte[] Key,byte[] IV)
        ...{
            // Create a MemoryStream to accept the encrypted bytes
            MemoryStream ms = new MemoryStream();
            
            // Create a symmetric algorithm.
            // We are going to use Rijndael because it is strong and
            // available on all platforms.
            // You can use other algorithms,to do so substitute the
            // next line with someting like
            //           TripleDES alg = TripleDES.Create();
            Rijndael alg = Rijndael.Create();

            // Now set the key and the IV
            // We need the IV(Initialization Vector) because the algorithm is
            // operating in its default mode call CBC(Cipher Block Chaining)
            // The IV is XORed with the first block (8 byte)
            // of the data before it is encrypted, and then each encrypted
            // block is XORed with the following block of plaintext.
            // This is done to make encryption more secure.

            // There is also a mode called ECB which does not need an IV,
            // But it is much less secure.
            alg.Key = Key;
            alg.IV  = IV ;

            // Create a CryptoStream though which we are going to be pumping
            // our data.
            // CryptoStreamMode.Write means that we are going to be writing data
            // to the stream and the output will be written in the MemoryStream
            // we have provided
            CryptoStream cs = new CryptoStream(ms,alg.CreateEncryptor(),
                CryptoStreamMode.Write);
            // Write the data and make it do the encryption
            cs.Write(clearData,0,clearData.Length);

            // Close the crypto stream (or do FlushFinalBlock)
            // This will tell it that we have done our encryption and 
            // There is no more data coming in,
            // and it is now a good time to apply the padding and finalize the
            // encryption process.
            cs.Close();
            // Now get the encrypted data from the MemoryStream.
            // Some people make a mistake of using GetBuffer() here,
            // which is not the right way.
            byte[] encryptedData = ms.ToArray();
            return encryptedData;
        }

        public static byte[] Decrypt(byte[] cipherData,byte[] Key ,byte[] IV)
        ...{
            // Create a MemoryStream that is going to accept the decrypted bytes
            MemoryStream ms = new MemoryStream();
            // Create a symmetric algorithm.
            // We are going to use Rijndael because it is strong and
            // available on all platforms.
            // You can use other algorithms,to do so substitute the
            // next line with someting like
            //           TripleDES alg = TripleDES.Create();
            Rijndael alg = Rijndael.Create();

            // Now set the key and the IV
            // We need the IV(Initialization Vector) because the algorithm is
            // operating in its default mode call CBC(Cipher Block Chaining)
            // The IV is XORed with the first block (8 byte)
            // of the data before it is encrypted, and then each encrypted
            // block is XORed with the following block of plaintext.
            // This is done to make encryption more secure.

            // There is also a mode called ECB which does not need an IV,
            // But it is much less secure.
            alg.Key = Key;
            alg.IV  = IV ;

            // Create a CryptoStream though which we are going to be pumping
            // our data.
            // CryptoStreamMode.Write means that we are going to be writing data
            // to the stream and the output will be written in the MemoryStream
            // we have provided
            CryptoStream cs = new CryptoStream(ms,alg.CreateDecryptor(),
                CryptoStreamMode.Write);
            // Write the data and make it do the encryption
            cs.Write(cipherData,0,cipherData.Length);
            // Close the crypto stream (or do FlushFinalBlock)
            // This will tell it that we have done our encryption and 
            // There is no more data coming in,
            // and it is now a good time to apply the padding and finalize the
            // encryption process.
            cs.Close();
            // Now get the encrypted data from the MemoryStream.
            // Some people make a mistake of using GetBuffer() here,
            // which is not the right way.
            byte [] decryptedData = ms.ToArray();
            return decryptedData;
        }

        public static string Encrypt(string clearText,string password)
        ...{
            // First we need to turn the input string into a byte array
            byte[] clearBytes = System.Text.Encoding.Default.GetBytes(clearText);
            // Then,we need to turn the password into key and iv
            // We are using salt to make it harder to guess our key
            // using a dictionary attack trying to guess password by enumerating
            // all possible words.
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(password,
                new byte[] ...{0x49,0x76,0x61,0x6e,0x20,0x4d,0x65,0x64,0x76
                               ,0x65,0x64,0x76,0x76});
            // Now get the key/IV and do the encryption using the function that
            // accepts byte arrays.
            // Using PasswordDeriveBytes object we are first getting 32 bytes for
            // the key
            // (the default Rijndael key length is 256bit = 32)
            // and then 16 bytes for the IV
            // IV should always be the block size ,which is by default
            // 16 bytes(128bit) for Rijndael
            // if you are using DES/TripleDES/RC2 the block size is 8 bytes 
            // and so should be the IV size
            // You can also read KeySize/BlockSize properties off
            // the algorithm to find out the sizes.
            byte [] encryptedData = Encrypt(clearBytes,pdb.GetBytes(32)
                , pdb.GetBytes(16));
            // Now we need to turn the resulting byte array into a string
            // Acommon mistake would be to use an Encoding class for that
            // It does not work because not all byte values can be
            // represented by characters.
            // We are going to be using Base64 encoding that is designed 
            // exactly for what we are trying to do.
            return Convert.ToBase64String(encryptedData);
        }

        public static string Decrypt(string cipherText,string password)
        ...{
            // First we need to turn the input string into a byte array
            byte[] cipherBytes = Convert.FromBase64String(cipherText);
            // Then,we need to turn the password into key and iv
            // We are using salt to make it harder to guess our key
            // using a dictionary attack trying to guess password by enumerating
            // all possible words.
            PasswordDeriveBytes pdb = new PasswordDeriveBytes(password,
                new byte[] ...{0x49,0x76,0x61,0x6e,0x20,0x4d,0x65,0x64,0x76
                               ,0x65,0x64,0x76,0x76});
            // Now get the key/IV and do the encryption using the function that
            // accepts byte arrays.
            // Using PasswordDeriveBytes object we are first getting 32 bytes for
            // the key
            // (the default Rijndael key length is 256bit = 32)
            // and then 16 bytes for the IV
            // IV should always be the block size ,which is by default
            // 16 bytes(128bit) for Rijndael
            // if you are using DES/TripleDES/RC2 the block size is 8 bytes 
            // and so should be the IV size
            // You can also read KeySize/BlockSize properties off
            // the algorithm to find out the sizes.
            byte [] decryptedData = Decrypt(cipherBytes,pdb.GetBytes(32)
                , pdb.GetBytes(16));
            return System.Text.Encoding.Default.GetString(decryptedData);
        }
    }
}