12,695,694 members (28,751 online)
Rate this:
See more:
I wrote an encryption application in C# which uses DES.
I wrote the encryption methods myself based on the DES algorithm description, not using the in-built methods for various reasons.
I checked it many times but still it still not working properly. It doesn't give back the original text after encryption and decryption.

I need ideas how can I find and correct the problem in my code!

I don't know what kind of bit array should i get after parts of encryption or decryption, so I can't locate the logical flaw in my code.
As last resort I could post/send my code, but I would be much happier if I could find the problem myself (based on your debugging ideas)!

UPDATE:
I don't want to use in built methods because I learn much more this way, and wanted to know if I like cryptographic programing or not...

```
//Execute the first permutation
public bool[] initialPermuation(bool[] sixtyfourbits)
{
bool[] bits = new bool[64];
int[] perm = new int[64]
{58, 50, 42, 34, 26, 18, 10, 2,
60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6,
64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1,
59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5,
63, 55, 47, 39, 31, 23, 15, 7};
for (int i = 0; i < 64; i++)
{
bits[i] = sixtyfourbits[perm[i] - 1];
}

return bits;
}

/// <summary>
/// Execute the first permutations inverz
/// </summary>
/// <param name="sixtyfourbitsR"></param>
/// <returns></returns>
public bool[] initialPermuationREV(bool[] sixtyfourbitsR)
{
bool[] bits = new bool[64];
int[] perm = new int[64]
{40, 8, 48, 16, 56, 24, 64, 32,
39,  7, 47, 15, 55, 23, 63, 31,
38, 6, 46, 14, 54, 22, 62, 30,
37, 5, 45, 13, 53, 21, 61, 29,
36, 4, 44, 12, 52, 20, 60, 28,
35, 3, 43, 11, 51, 19, 59, 27,
34, 2, 42, 10, 50, 18, 58, 26,
33, 1, 41, 9, 49, 17, 57, 25};
for (int i = 0; i < 64; i++)
{
bits[i] = sixtyfourbitsR[perm[i] - 1];
}

return bits;
}

/// <summary>
/// Execute a XOR operation
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <returns></returns>
private bool plusz(bool one, bool two)
{
bool end = false;
if (one || two) end = true;
if (one && two) end = false;

return end;
}

/// <summary>
/// Execute the XOR operation in two 32 bit array
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <returns></returns>
private bool[] plusz32(bool[] one, bool[] two)
{
for (int i = 0; i < 32; i++)
{
one[i] = plusz(one[i], two[i]);
}
return one;
}

/// <summary>
/// Execute the convertion from 32 bits to 48 bits
/// </summary>
/// <param name="alap"></param>
/// <returns></returns>
private bool[] E32bitTO48(bool[] alap)
{
bool[] kimeno = new bool[48];
int[] perm = new int[48]
{32, 1, 2, 3, 4, 5,
4, 5, 6, 7, 8, 9,
8, 9, 10, 11, 12, 13,
12, 13, 14, 15, 16, 17,
16, 17, 18, 19, 20, 21,
20, 21, 22, 23, 24, 25,
24, 25, 26, 27, 28, 29,
28, 29, 30, 31, 32, 1};

for (int i = 0; i < 48; i++)
{
kimeno[i] = alap[perm[i] - 1];
}

return kimeno;
}

/// <summary>
/// Execute the permutation for the 32 bits
/// </summary>
/// <param name="alap"></param>
/// <returns></returns>
private bool[] permutation32bit(bool[] alap)
{
bool[] bits = new bool[32];
int[] perm = new int[32]
{16, 7, 20, 21,
29, 12, 28, 17,
1, 15, 23, 26,
5, 18, 31, 10,
2, 8, 24, 14,
32, 27, 3, 9,
19, 13, 30, 6,
22, 11, 4, 25};

for (int i = 0; i < 32; i++)
{
bits[i] = alap[perm[i] - 1];
}

return bits;
}

/// <summary>
/// Executes a permutation and divides the base bits into two array
/// </summary>
/// <param name="alap"></param>
/// <param name="keyD"></param>
/// <returns></returns>
private bool[] permutation1Key(bool[] alap, out bool[] keyD)
{
keyD = new bool[28];
bool[] bits = new bool[28];
int[] perm = new int[28]
{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};
int[] perm2 = new int[28]
{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};

for (int i = 0; i < 28; i++)
{
bits[i] = alap[perm[i] - 1];
}
for (int i = 0; i < 28; i++)
{
keyD[i] = alap[perm2[i] - 1];
}

return bits;
}

/// <summary>
/// Adds two 28 bit array, then execute the 48 bits permutation
/// </summary>
/// <param name="alap1"></param>
/// <param name="alap2"></param>
/// <returns></returns>
private bool[] permutation2Key(bool[] alap1, bool[] alap2)
{
bool[] summ = new bool[56];
bool[] bits = new bool[48];
for (int i = 0; i < 28; i++)
{
summ[i] = alap1[i];
summ[28 + i] = alap2[i];
}
int[] perm = new int[48]
{14, 17, 11, 24, 1, 5,
3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8,
16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55,
30, 40, 51, 45, 33, 48,
44, 49, 39, 56, 34, 53,
46, 42, 50, 36, 29, 32};

for (int i = 0; i < 48; i++)
{
bits[i] = summ[perm[i] - 1];
}

return bits;
}

/// <summary>
/// Left shift
/// </summary>
/// <param name="szam">How many times it executes</param>
/// <param name="alap"></param>
/// <returns></returns>
private bool[] leftShift(int szam, bool[] alap)
{
bool[] bits = new bool[alap.Length];
int z = shifts[szam - 1];
for (int j = 0; j < z; j++)
{
for (int i = 0; i < alap.Length; i++)
{
if (i != alap.Length - 1) bits[i] = alap[i + 1];
else bits[i] = alap[0];
}
}
return bits;
}

/// <summary>
/// Sets the column and row for the S algorithm
/// </summary>
/// <param name="alap"></param>
/// <param name="second">Column number</param>
/// <returns>Row number</returns>
private int sSelection(bool[] alap, out int second)
{
int ki = 0;
second = 0;
if (alap[0]) ki = ki + 2;
if (alap[5]) ki = ki + 1;
if (alap[1]) second = second + 8;
if (alap[2]) second = second + 4;
if (alap[3]) second = second + 2;
if (alap[4]) second = second + 1;

return ki;
}

/// <summary>
/// Converts the numbers got from one the S part of the encryption into bits
/// </summary>
/// <param name="xy"></param>
/// <returns></returns>
private bool[] sAddOut(int xy)
{
bool[] bits = new bool[4];
if (xy >= 8)
{
bits[0] = true;
xy = xy - 8;
}
else bits[0] = false;
if (xy >= 4)
{
bits[1] = true;
xy = xy - 4;
}
else bits[1] = false;
if (xy >= 2)
{
bits[2] = true;
xy = xy - 2;
}
else bits[2] = false;
if (xy >= 1)
{
bits[3] = true;
xy = xy - 1;
}
else bits[3] = false;

return bits;
}

/// <summary>
/// Creates the needed subkey
/// </summary>
/// <param name="KeyN">The parameter for which key is needed</param>
/// <returns>The key bits</returns>
private bool[] KeyGeneration(int KeyN)
{
if (txtkey.Text == "" || txtkey.Text.Length != 8) MessageBox.Show("Nem megfelelő kulcs!");
char[] kulcs = txtkey.Text.ToCharArray();
bool[] kulcsbits = chartoBool(kulcs);
bool[] Dn;
bool[] Cn = permutation1Key(kulcsbits, out Dn);
for (int i = 0; i < KeyN; i++)
{
Cn = leftShift(i + 1, Cn);
Dn = leftShift(i + 1, Dn);
}
bool[] bits = permutation2Key(Cn, Dn);
return bits;
}

/// <summary>
/// Executes one part of the encryption sequence
/// </summary>
/// <param name="alapX"></param>
/// <param name="KulcsN"></param>
/// <returns></returns>
private bool[] fScrpyt(bool[] alapX, bool[] KulcsN)
{
bool[] bits = new bool[48];
bits = E32bitTO48(alapX);
for (int i = 0; i < 48; i++)
{
bits[i] = plusz(bits[i], KulcsN[i]);
}
bool[][] bitA = new bool[8][];
bool[][] bitA2 = new bool[8][];
for (int i = 0; i < 8; i++)
{
bitA[i] = new bool[6];
for (int j = 0; j < 6; j++)
{
bitA[i][j] = bits[j + i * 6];
}
}
int Sx, Sy;
Sx = sSelection(bitA[0], out Sy);
bitA2[0] = sAddOut(S1[Sx, Sy]);
Sx = sSelection(bitA[1], out Sy);
bitA2[1] = sAddOut(S2[Sx, Sy]);
Sx = sSelection(bitA[2], out Sy);
bitA2[2] = sAddOut(S3[Sx, Sy]);
Sx = sSelection(bitA[3], out Sy);
bitA2[3] = sAddOut(S4[Sx, Sy]);
Sx = sSelection(bitA[4], out Sy);
bitA2[4] = sAddOut(S5[Sx, Sy]);
Sx = sSelection(bitA[5], out Sy);
bitA2[5] = sAddOut(S6[Sx, Sy]);
Sx = sSelection(bitA[6], out Sy);
bitA2[6] = sAddOut(S7[Sx, Sy]);
Sx = sSelection(bitA[7], out Sy);
bitA2[7] = sAddOut(S8[Sx, Sy]);

bool[] thirtytwo = new bool[32];
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 4; j++)
{
thirtytwo[i * 4 + j] = bitA2[i][j];
}
}

return permutation32bit(thirtytwo);
}

/// <summary>
/// Divides a 64 bit array into two 32 bit array
/// </summary>
/// <param name="alap"></param>
/// <param name="second"></param>
/// <returns></returns>
private bool[] seperate(bool[] alap, out bool[] second)
{
bool[] bits = new bool[32];
second = new bool[32];
for (int i = 0; i < 32; i++)
{
bits[i] = alap[i];
}
for (int i = 0; i < 32; i++)
{
second[i] = alap[32 + i];
}
return bits;
}

/// <summary>
/// Adds two 32 bit array into a 64 bit array
/// </summary>
/// <param name="one"></param>
/// <param name="two"></param>
/// <returns></returns>
private bool[] pluszbool64(bool[] one, bool[] two)
{
bool[] all = new bool[64];
for (int i = 0; i < 32; i++)
{
all[i] = one[i];
}
for (int i = 0; i < 32; i++)
{
all[32 + i] = two[i];
}
return all;
}

/// <summary>
/// Execute the encrypton algorithm
/// </summary>
/// <param name="textbits"></param>
/// <returns></returns>
private bool[] Encrpytion(bool[] textbits)
{
int hossz = textbits.Length / 64;
bool[] bits = new bool[64];
for (int i = 0; i < hossz; i++)
{
for (int j = 0; j < 64; j++)
{
bits[j] = textbits[j + i * 64];
}

bits = initialPermuation(bits);

bool[] left = new bool[32];
bool[] right = new bool[32];
bool[] leftN = new bool[32];
bool[] rightN = new bool[32];

left = seperate(bits, out right);

for (int ii = 0; ii < 16; ii++)
{
leftN = right;
rightN = plusz32(left, fScrpyt(right, KeyGeneration(ii + 1)));

left = leftN;
right = rightN;
}
bits = pluszbool64(right, left);
}

return initialPermuationREV(bits);
}

/// <summary>
/// Execute the decryptom algorithm
/// </summary>
/// <param name="textbits"></param>
/// <returns></returns>
private bool[] Decrpytion(bool[] textbits)
{
int hossz = textbits.Length / 64;
bool[] bits = new bool[64];
for (int i = 0; i < hossz; i++)
{
for (int j = 0; j < 64; j++)
{
bits[j] = textbits[j + i * 64];
}

bits = initialPermuationREV(bits);

bool[] left = new bool[32];
bool[] right = new bool[32];
bool[] leftN = new bool[32];
bool[] rightN = new bool[32];

left = seperate(bits, out right);

leftN = left;
left = right;
right = leftN;

for (int ii = 16; ii > 0; ii--)
{
rightN = left;
leftN = plusz32(right, fScrpyt(left, KeyGeneration(ii)));

left = leftN;
right = rightN;
}
bits = pluszbool64(right, left);
}

return initialPermuation(bits);
}

int[,] S1 = new int[4, 16] {
{ 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}};

int[,] S2 = new int[4, 16]
{{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
{2, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
{0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
{13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}};

int[,] S3 = new int[4, 16]
{{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
{13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
{13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
{1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}};

int[,] S4 = new int[4, 16]
{{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
{13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
{10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
{3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}};

int[,] S5 = new int[4, 16]
{{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
{14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
{4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
{11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}};

int[,] S6 = new int[4, 16]
{{10, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
{10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
{9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
{4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}};

int[,] S7 = new int[4, 16]
{{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
{13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
{1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
{6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}};

int[,] S8 = new int[4, 16]
{{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
{1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
{7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
{2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}};

int[] shifts = new int[16] { 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 };
```
Posted 31-May-12 10:21am
Updated 31-May-12 12:17pm
v2
db7uk 31-May-12 15:26pm

Cryptography is complex. Can you provide any code (probably not)? Why is the inbuilt .Net cryptography not to your liking?
Dr. Sakraf 31-May-12 17:25pm

Yeah, I can provide (the code). I wouldn't have asked without me making the code, and trying to debug it for a week first :)
Oleksandr Kulchytskyi 31-May-12 15:54pm

Please provide us with some code fragment.
It's very difficult to figure out issue only with help of words....
Bernhard Hiller 1-Jun-12 4:50am

I worked with Rijndael somewhen ago. When I remember correctly, Int32 were used, not bits. Hence I doubt that those bool[32] are correct - instead of int.

Rate this:

## Solution 1

We can't help much at all.

We have no idea how you have implemented the algorithms, let alone how you have implemented the code that uses them - and they aren't simple algorithms to implement in the first place!

I would start by implementing the same code, but using the built in DES encryption, and comparing the output. If there is something really obvious - like your files are a quarter the size - that that would at least give you a clue. If they are the same size, then start looking at the data - does it have any similarities at all? But then, when you have implemented it using the standard methods, does it matter why your version doesn't work? Do you have the time to find out?

But to be honest, even with your code, I suspect that you are going to be on your own on this one - and without it, we can't even make constructive suggestions.

Sorry.
Dr. Sakraf 31-May-12 17:20pm

Thanks. Your right, i should have shared it at the beginning.
Also the sizes are right, because I get back the same amount of bits, I supplied at the first place.
lewax00 31-May-12 18:33pm

Still, checking against the built in one can tell you if your error is in the encryption stage, decryption stage, or both.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Top Experts
Last 24hrsThis month
 OriginalGriff 385 ppolymorphe 103 Peter Leow 80 Richard Deeming 80 Richard MacCutchan 60
 OriginalGriff 3,463 Peter Leow 2,145 Mika Wendelius 1,743 ppolymorphe 1,579 Jochen Arndt 1,364

Advertise | Privacy | Mobile
Web02 | 2.8.170118.1 | Last Updated 31 May 2012