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);
}
}
}
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);
}
}
}