Click here to Skip to main content
Rate this: bad
good
Please Sign up or sign in to vote.
See more: C# Encryption Debugging
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 9:21am
Edited 31-May-12 11:17am
v2
Comments
db7uk at 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 at 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 at 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 at 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.

1 solution

Rate this: bad
good
Please Sign up or sign in to vote.

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.
  Permalink  
Comments
Dr. Sakraf at 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 at 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)

  Print Answers RSS
0 Sergey Alexandrovich Kryukov 6,805
1 OriginalGriff 6,696
2 CPallini 5,350
3 George Jonsson 3,609
4 Gihan Liyanage 2,792


Advertise | Privacy | Mobile
Web02 | 2.8.140922.1 | Last Updated 31 May 2012
Copyright © CodeProject, 1999-2014
All Rights Reserved. Terms of Service
Layout: fixed | fluid

CodeProject, 503-250 Ferrand Drive Toronto Ontario, M3C 3G8 Canada +1 416-849-8900 x 100