## Introduction

It's a simple DES/AES Encrypt and Decrypt program that uses string data type. If it helps someone who needs to get some practical source code, it'll be my honor.

**Caution**: I'm not good at writing in English, so be careful if there are some inappropriate sentences. Thank you... hahaha.

## Background

Background? Understanding about C#2.0 and string data type and, of course, Cryptography.

I got so many(???) complaints about tell-you-nothing posts.

So I will describe some implementation of The Simple Cryptographer.

But it's too stupid to reinvent the wheel, so I recommend reading some good articles about DES and AES.

I read these articles when I implemented The Simple Cryptographer.

#### How DES Wrks in SimpleCryptographer

First, al the permutation tables in DES and the S-BOXes are declared like this:

public static readonly int[] pc_1 ={ 57, 49, 41, 33, 25, 17, 9, 1, 58, 50,
42, 34, 26, 18, 10, 2, 59, 51, 43, 35,
27, 19, 11, 3, 60, 52, 44, 36, 63, 55,
47, 39, 31, 23, 15, 7, 62, 54, 46, 38,
30, 22, 14, 6, 61, 53, 45, 37, 29, 21,
13, 5, 28, 20, 12, 4 };
public static readonly int[,] s1 ={ { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9,
0, 7 },
{ 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9,
5, 3, 8 },
{ 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3,
10, 5, 0 },
{ 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10,
0, 6, 13 } };

All the other methods in the `ProcessDES `

class except `EncryptionStart`

, `DecryptionStart`

, `DoPermutation`

, `SetAllKeys`

, `FinalEncription`

, `f`

, `P`

, `sBox_Transform`

, `E_Selection `

are just helper methods, so just focus on DES-process.

And it starts with making 16-sub keys.

string hex_key = this.FromTextToHex(key);
string binary_key = this.FromHexToBinary(hex_key);
string key_plus = this.DoPermutation(binary_key, DESData.pc_1);
string C0 = "", D0 = "";
C0 = this.SetLeftHalvesKey(key_plus);
D0 = this.SetRightHalvesKey(key_plus);
Keys keys = this.SetAllKeys(C0, D0);

The key input is hexa decimal, so convert it to binary decimal for bit permutations and transformations.

And permutate the key by permutation table PC-1, and split this key into left and right halves, `C0 `

and `D0`

.

And make 16 sub-keys.

public Keys SetAllKeys(string C0, string D0)
{
Keys keys = new Keys();
keys.Cn[0] = C0;
keys.Dn[0] = D0;
for (int i = 1; i < keys.Cn.Length; i++)
{
keys.Cn[i] = this.LeftShift(keys.Cn[i - 1], DESData.nrOfShifts[i]);
keys.Dn[i] = this.LeftShift(keys.Dn[i - 1], DESData.nrOfShifts[i]);
keys.Kn[i - 1] = this.DoPermutation(keys.Cn[i] + keys.Dn[i],
DESData.pc_2);
}
return keys;
}

It's just the implementation of create 16-subkeys in DES.

Please refer to a good explanation in the linked DES article above.

And now, encrypt data block process.

binaryText = this.setTextMutipleOf64Bits(binaryText);
StringBuilder EncryptedTextBuilder = new StringBuilder(binaryText.Length);
**for (int i = 0; i < (binaryText.Length / 64); i++)
{
string PermutatedText = this.DoPermutation(binaryText.Substring(i * 64, 64),
DESData.ip);**
** string L0 = "", R0 = "";**
** L0 = this.SetLeftHalvesKey(PermutatedText);
R0 = this.SetRightHalvesKey(PermutatedText);**
** string FinalText = this.FinalEncription(L0, R0, keys, false);**
** EncryptedTextBuilder.Append(FinalText);**
**}**

First, set the total data size to a multiple of 64bit because DES is a block cipher that encrypts 64bit data block at once.

I use `StringBuilder `

for reducing string garbage, but I think string is not a good choice for performance but good for implementation (easy ).

public string FinalEncription(string L0, string R0, Keys keys, bool IsReverse)
{
string Ln = "", Rn = "", Ln_1 = L0, Rn_1 = R0;
int i = 0;
if (IsReverse == true)
{
i = 15;
}
while (this.IsEnough(i, IsReverse))
{
Ln = Rn_1;
Rn = this.XOR(Ln_1, this.f(Rn_1, keys.Kn[i]));
Ln_1 = Ln;
Rn_1 = Rn;
if (IsReverse == false)
{
i += 1;
}
else
{
i -= 1;
}
}
string R16L16 = Rn + Ln;
string Encripted_Text = this.DoPermutation(R16L16, DESData.ip_1);
return Encripted_Text;
}

It's the final process of encryption.

The "`IsReverse`

" flag is for using the same method for encryption and decryption.

#### How AES Works in SimpleCryptographer

It's hard to describe AES in detail for me. But I think flash animation that I linked above will be a great help. So I describe the basic building blocks of the Simple Cryptographer.

In AES, it uses a matrix-like data structure, state, so I designed a matrix-like class:

class Matrix
{
#region Private Fields
private string[,] matrix;
private int rows = 0;
private int columns = 0;
#endregion
#region Constructor
public Matrix(int rows, int columns)
: this("", rows, columns)
{
}
public Matrix(string text)
: this(text, 4, 4)
{
}
public Matrix(string text, int rows, int columns)
{
if (text.Length != columns * rows * 8)
{
text = text.PadRight(columns * rows * 8 - text.Length, '0');
}
matrix = new string[rows, columns];
int count = 0;
this.rows = rows;
this.columns = columns;
for (int i = 0; i < columns; i++)
{
for (int j = 0; j < rows; j++)
{
matrix[j, i] = text.Substring(count * 8, 8);
count++;
}
}
}
#endregion
#region Properties, Indexer
public int Rows
{
get
{
return rows;
}
}
public int Columns
{
get
{
return columns;
}
}
public string this[int i, int j]
{
get
{
return matrix[i, j];
}
set
{
if (value.Length == 2)
{
matrix[i, j] = BaseTransform.FromHexToBinary(value);
}
else if (value.Length == 8)
{
matrix[i, j] = value;
}
}
}
#endregion
#region Overrided ToString method
public override string ToString()
{
StringBuilder text = new StringBuilder(128);
if (matrix != null)
{
for (int j = 0; j < columns; j++)
{
for (int i = 0; i < rows; i++)
{
text.Append(matrix[i, j]);
}
}
}
return text.ToString();
}
#endregion
#region one row operation
public string[] getRow(int rowindex)
{
string[] row = new string[this.columns];
if (rowindex > this.rows)
{
throw new IndexOutOfRangeException("It's out of index.");
}
for (int i = 0; i < this.columns; i++)
{
row[i] = matrix[rowindex, i];
}
return row;
}
public void setRow(string[] row, int rowindex)
{
if (rowindex > this.rows)
{
throw new IndexOutOfRangeException("It's out of index.");
}
for (int i = 0; i < this.columns; i++)
{
matrix[rowindex, i] = row[i];
}
}
#endregion
#region one column operation
public string[] getWord(int wordindex)
{
string[] word = new string[this.rows];
if (wordindex > this.rows)
{
throw new IndexOutOfRangeException("It's out of index.");
}
for (int i = 0; i < this.rows; i++)
{
word[i] = matrix[i, wordindex];
}
return word;
}
public void setWord(string[] word, int wordindex)
{
if (wordindex > this.rows)
{
throw new IndexOutOfRangeException("It's out of index.");
}
for (int i = 0; i < this.rows; i++)
{
matrix[i, wordindex] = word[i];
}
}
#endregion
}

It implements one row calculation, one column(one word in AES) calculation and indexer and I use it all of code in AES implementation like the code below.

public static Matrix XOR(Matrix a, Matrix b)
{
Matrix c = new Matrix(a.Rows, a.Columns);
for (int i = 0; i < c.Rows; i++)
{
for (int j = 0; j < c.Columns; j++)
{
c[i, j] = MultiplicativeInverse.XOR(a[i, j], b[i, j]);
}
}
return c;
}

And the module that calculates bit as polynomial that has binary coefficient is multiplicativeinverse class. In AES, it uses multiplication on GF(*2*^{8}).

public static string GetInverse(string text1, string text2, string mx, int n)
{
string[] multiplyTable = new string[n];
if (text1.IndexOf('1') > text2.IndexOf('1'))
{
string temp = text2;
text2 = text1;
text1 = temp;
}
multiplyTable[0] = text1;
for (int i = 1; i < n; i++)
{
multiplyTable[i] = MultiplicativeInverse.LeftShift2(multiplyTable[i - 1],
n);
if (multiplyTable[i - 1][text1.Length - n].Equals('1'))
{
multiplyTable[i] = MultiplicativeInverse.XOR(multiplyTable[i], mx);
}
}
string Mul_Inverse = "";
for (int i = 0; i < text2.Length; i++)
{
if (text2[i].Equals('1'))
{
if (Mul_Inverse.Equals(""))
{
Mul_Inverse = multiplyTable[(text2.Length - 1) - i];
}
else
{
Mul_Inverse = MultiplicativeInverse.XOR(Mul_Inverse,
multiplyTable[(text2.Length - 1) - i]);
}
}
}
if (Mul_Inverse.Equals(""))
{
Mul_Inverse = "00000000";
}
return Mul_Inverse;
}

Mx is reduction modulo, n is greatest degree of a polynomial. If bit string of 1byte "01000100" converts to polynomial on GF(*2*^{8}), x^{7} + x^{2}. Detailed process of AES and calculate multiplication on GF(*2*^{8}) is better, see book or web site. (I recommend Wikipedia.)

#### Very Very Very Simple Elapsed Time Checking (Appended)

DateTime start = DateTime.Now;
this.StartSelectedProcess();
DateTime end = DateTime.Now;
TimeSpan result = end - start;
lblProgress.Text = "Elapsed Time : " + result.ToString();

That's it.

## Using the Code

It has two core classes, `ProcessDES`

, `ProcessAES`

. As you can see, these classes process encryption and decryption using DES and AES.

These classes are derived from abstract class, `CommonProcess `

that has `EncryptionStart`

, `DecryptionStart`

. These methods are common interface for `ProcessDES`

, `ProcessAES`

. If I have not misunderstood, changing the algorithm between DES and AES in this program is implemented by Factory Pattern. Using the common interface `CommonProcess`

.

Other classes are some building blocks of DES and AES, transform from text to hexadecimal, hexadecimal to text, to binary, and some core building block like multiplication on GF(*2*^{8}), matrix transformation....etc....

All of these algorithms are implemented by string data. It's bad for many times of transformation because it's immutable. If you change value, original value is replaced by the new one, and the old one is garbage. It's the reason for using `StringBuilder `

in many times loops like `for `

and `while`

. I considered it while I wrote the program but I don't assure about performance.

## Points of Interest

I started learning Cryptography two weeks ago, and I made this program. It really helps me in understanding the detail implementation of DES and AES.

## History

- The progressbar for Encryption and Decryption was appended (2007/5/3)
- Count elapsed time was appended (2007/5/8)
- Count detailed elapsed time that is more than a second that just shows the result time at the end of the process was appended (2007/5/9)
- Fix bug that it cuts some texts out during decryption (2007/5/10)
- Check an input key to see whether it is hexadecimal or not (2007/5/21)