static void Main(string[] args)
{
Console.WriteLine("This example shows how to use the symmetric encryption classes from the Security Library.\r\n");
SymmetricAlgorithm algorithm;
ICryptoTransform encryptor, decryptor;
Console.WriteLine("Select the symmetric algorithm you want to use:");
Console.WriteLine(" [1] ARCFour [managed RC4]");
Console.WriteLine(" [2] RC4 [unmanaged]");
Console.WriteLine(" [3] Rijndael");
Console.Write("Your choice: ");
string input = Console.ReadLine().Trim();
// initialize the selected symmetric algorithm
switch (input)
{
case "1":
algorithm = new ARCFourManaged();
break;
case "2":
algorithm = new RC4CryptoServiceProvider();
break;
case "3":
algorithm = new RijndaelCryptoServiceProvider();
break;
default:
Console.WriteLine("Invalid input.");
return;
}
Console.WriteLine("Enter some text that will be encrypted:");
input = Console.ReadLine();
byte[] plaintext = Encoding.ASCII.GetBytes(input);
// generate an IV that consists of bytes with the value zero
// in real life applications, the IV should not be set to
// an array of bytes with the value zero!
algorithm.IV = new byte[algorithm.BlockSize / 8];
// generate a new key
algorithm.GenerateKey();
// create the encryption and decryption objects
encryptor = algorithm.CreateEncryptor();
decryptor = algorithm.CreateDecryptor();
// encrypt the bytes
byte[] encrypted = encryptor.TransformFinalBlock(plaintext, 0, plaintext.Length);
// decrypt the encrypted bytes
byte[] decrypted = decryptor.TransformFinalBlock(encrypted, 0, encrypted.Length);
// write the byte arrays to the console
Console.WriteLine("\r\nResults:");
Console.WriteLine(" Input data: " + Encoding.ASCII.GetString(plaintext));
Console.WriteLine(" Key: " + BytesToHex(algorithm.Key));
Console.WriteLine(" Encrypted data: " + BytesToHex(encrypted));
Console.WriteLine(" Decrypted data: " + Encoding.ASCII.GetString(decrypted));
Console.WriteLine("\r\nPress ENTER to continue...");
Console.ReadLine();
// dispose of the resources
algorithm.Clear();
encryptor.Dispose();
decryptor.Dispose();
}
private int StartTest(int keySize, int blockSize, PaddingMode padding, CipherMode mode)
{
Rijndael rm, ru;
try {
rm = new RijndaelManaged();
ru = new RijndaelCryptoServiceProvider();
rm.KeySize = ru.KeySize = keySize;
rm.BlockSize = ru.BlockSize = blockSize;
rm.Padding = ru.Padding = padding;
rm.Mode = ru.Mode = mode;
rm.GenerateIV();
ru.IV = rm.IV;
rm.GenerateKey();
ru.Key = rm.Key;
} catch {
AddError("RUT-ST01");
return(1);
}
ICryptoTransform rmt, rut;
// test encryption
try {
rmt = rm.CreateEncryptor();
rut = ru.CreateEncryptor();
} catch {
AddError("RUT-ST02");
return(2);
}
if (rmt.InputBlockSize != rut.InputBlockSize)
{
AddError("RUT-ST03");
}
if (rmt.OutputBlockSize != rut.OutputBlockSize)
{
AddError("RUT-ST04");
}
byte[] toEncrypt = new byte[123];
new RNGCryptoServiceProvider().GetBytes(toEncrypt);
byte[] me, ue;
try {
me = rmt.TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
} catch {
AddError("RUT-ST05");
return(5);
}
try {
ue = rut.TransformFinalBlock(toEncrypt, 0, toEncrypt.Length);
} catch {
AddError("RUT-ST06");
return(6);
}
if (!ArrayEquals(me, ue))
{
AddError("RUT-ST07");
}
byte[] menc = null;
byte[] uenc = null;
int uo = 0, mo = 0;
try {
menc = new byte[toEncrypt.Length + rmt.OutputBlockSize];
uenc = new byte[toEncrypt.Length + rut.OutputBlockSize];
for (int i = 0; i < toEncrypt.Length; i += rmt.InputBlockSize)
{
if (toEncrypt.Length > i + rmt.InputBlockSize)
{
mo += rmt.TransformBlock(toEncrypt, i, rmt.InputBlockSize, menc, mo);
uo += rut.TransformBlock(toEncrypt, i, rut.InputBlockSize, uenc, uo);
}
else
{
if (padding == PaddingMode.PKCS7)
{
byte[] temp = rmt.TransformFinalBlock(toEncrypt, i, toEncrypt.Length - i);
Array.Copy(temp, 0, menc, mo, temp.Length);
mo += temp.Length;
temp = rut.TransformFinalBlock(toEncrypt, i, toEncrypt.Length - i);
Array.Copy(temp, 0, uenc, uo, temp.Length);
uo += temp.Length;
}
}
}
} catch {
AddError("RUT-ST08");
}
if (mo != uo || !ArrayEquals(menc, uenc, 0, mo))
{
AddError("RUT-ST09");
}
if (padding == PaddingMode.PKCS7)
{
if (mo != me.Length || uo != ue.Length)
{
AddError("RUT-ST10");
}
if (!ArrayEquals(menc, me, 0, mo))
{
AddError("RUT-ST11");
}
if (!ArrayEquals(uenc, ue, 0, uo))
{
AddError("RUT-ST12");
}
}
// test decryption
try {
rmt = rm.CreateDecryptor();
rut = ru.CreateDecryptor();
} catch {
AddError("RUT-ST13");
return(13);
}
if (rmt.InputBlockSize != rut.InputBlockSize)
{
AddError("RUT-ST14");
}
if (rmt.OutputBlockSize != rut.OutputBlockSize)
{
AddError("RUT-ST15");
}
byte[] md, ud;
try {
md = rmt.TransformFinalBlock(me, 0, me.Length);
} catch {
AddError("RUT-ST16");
return(16);
}
try {
ud = rut.TransformFinalBlock(ue, 0, ue.Length);
} catch {
AddError("RUT-ST17");
return(17);
}
if (!ArrayEquals(md, ud))
{
AddError("RUT-ST18");
}
byte[] mdec = null;
byte[] udec = null;
int uod = 0, mod = 0;
try {
mdec = new byte[me.Length];
udec = new byte[ue.Length];
for (int i = 0; i < me.Length; i += rmt.InputBlockSize)
{
if (me.Length > i + rmt.InputBlockSize)
{
mod += rmt.TransformBlock(me, i, rmt.InputBlockSize, mdec, mod);
uod += rut.TransformBlock(ue, i, rut.InputBlockSize, udec, uod);
}
else
{
if (padding == PaddingMode.PKCS7)
{
byte[] temp = rmt.TransformFinalBlock(me, i, me.Length - i);
Array.Copy(temp, 0, mdec, mod, temp.Length);
mod += temp.Length;
temp = rut.TransformFinalBlock(ue, i, ue.Length - i);
Array.Copy(temp, 0, udec, uod, temp.Length);
uod += temp.Length;
}
}
}
} catch {
AddError("RUT-ST19");
}
if (mod != uod || !ArrayEquals(mdec, udec, 0, mod))
{
AddError("RUT-ST20");
}
if (padding == PaddingMode.PKCS7)
{
if (mod != md.Length || uod != ud.Length)
{
AddError("RUT-ST21");
}
if (!ArrayEquals(mdec, md, 0, md.Length))
{
AddError("RUT-ST22");
}
if (!ArrayEquals(udec, ud, 0, ud.Length))
{
AddError("RUT-ST23");
}
if (!ArrayEquals(ud, toEncrypt))
{
AddError("RUT-ST24");
}
}
return(24);
}
