source: trunk/CrypPlugins/PlayfairAnalysis/Program.cs @ 1939

Last change on this file since 1939 was 1939, checked in by Christoph Hartmann, 11 years ago

Playfair Analysis Plugin (basically runs, but not ready yet)

File size: 28.6 KB
RevLine 
[1939]1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.Collections;
6using Mischel.Collections;
7
8
9namespace PlayFair
10{
11    class Program
12    {
13       
14 
15        static void Main(string[] args)
16        {
17            Matrix Key = new Matrix();
18            Double[,] BigraphStat = new Double[25,25];
19
20            // CreateBS(@"H:\BS\BS.txt", @"H:\BS\BS.xml");
21           
22           
23            // Read Bigraph Statistic from xml file
24            string BsPath = @"H:\BS\BSLog10.xml";
25            System.Xml.Serialization.XmlSerializer ReadBS = new System.Xml.Serialization.XmlSerializer(typeof(Double[][]));
26            System.Xml.XmlReader XmlReader = System.Xml.XmlReader.Create(BsPath);
27            Double[][] BigraphStatDummy = (Double[][])ReadBS.Deserialize(XmlReader);
28            XmlReader.Close();
29
30            for (int i = 0; i < 25; i++)
31            {
32                for (int j = 0; j < 25; j++)
33                {
34                    BigraphStat[i,j] = BigraphStatDummy[i][j];
35                }
36            }
37
38            // Read Key from txt file
39            Key.ReadMatrixFile(@"H:\Key.txt");
40
41            // Create Ciphertext from txt file
42            string CipherText = PlayFair.Encrypt(Key, PlayFair.Format(System.IO.File.ReadAllText(@"H:\Plaintext.txt")));
43                     
44                       
45            string CrackedCipherText = PlayFair.Attack(CipherText, BigraphStat);
46
47                             
48            Console.WriteLine("\nMatch: " + (CrackedCipherText == PlayFair.Format(System.IO.File.ReadAllText(@"H:\Plaintext.txt"))));
49            Console.WriteLine("\nCracked Cipher:\n\n" + CrackedCipherText);           
50            Console.In.ReadLine();
51           
52                       
53        }
54
55        // Create a Bigraph Statistic and write in both txt and xml file
56        static void CreateBS(string PathTxt, string PathXml)
57        {
58            string[] StatTextPath = { @"H:\Texte\Text1.txt", @"H:\Texte\Text2.txt", @"H:\Texte\Text3.txt", @"H:\Texte\Text4.txt",
59                                      @"H:\Texte\Text5.txt", @"H:\Texte\Text6.txt", @"H:\Texte\Text7.txt", @"H:\Texte\Text8.txt",
60                                      @"H:\Texte\Text9.txt", @"H:\Texte\Text10.txt", @"H:\Texte\Text11.txt", @"H:\Texte\Text12.txt",
61                                      @"H:\Texte\Text13.txt", @"H:\Texte\Text14.txt", @"H:\Texte\Text15.txt", @"H:\Texte\Text16.txt",
62                                      @"H:\Texte\Text17.txt", @"H:\Texte\Text18.txt", @"H:\Texte\Text19.txt", @"H:\Texte\Text20.txt"};
63
64            BigraphStatistic BS = new BigraphStatistic();
65            int[,] BigraphStat = BS.Generate(StatTextPath);
66
67            string[] Tab = new string[25];
68            for (int i = 0; i < 25; i++)
69            {
70                for (int j = 0; j < 25; j++)
71                {
72                    Tab[i] += Convert.ToString(BigraphStat[i, j]) + " ";
73                    Tab[i] += "\t";
74                }
75            }
76
77            System.IO.File.WriteAllLines(PathTxt, Tab);
78
79            int[][] BigraphStatDummy = new int[25][];
80
81            for (int i = 0; i < 25; i++)
82            {
83                BigraphStatDummy[i] = new int[25];
84                for (int j = 0; j < 25; j++)
85                {
86                    BigraphStatDummy[i][j] = BigraphStat[i, j];
87                }
88            }
89                       
90            System.Xml.Serialization.XmlSerializer WriteBS = new System.Xml.Serialization.XmlSerializer(typeof(Int32[][]));
91            System.Xml.XmlWriter XmlWriter = System.Xml.XmlWriter.Create(PathXml);
92            WriteBS.Serialize(XmlWriter, BigraphStatDummy);
93            XmlWriter.Close();
94
95            // Compute log-probabilities
96            int sum = 0;
97            foreach (int value in BigraphStat)
98                sum += value;
99           
100
101            double[][] BigraphStatLog = new double[25][];
102
103            for (int i = 0; i < 25; i++ )
104            {
105                BigraphStatLog[i] = new double[25];
106                for (int j = 0; j < 25; j++)
107                {                   
108                    if (BigraphStat[i, j] > 0)
109                    {
110                        BigraphStatLog[i][j] = Math.Log((double)BigraphStat[i, j] / sum);                       
111                    }
112                    else
113                        BigraphStatLog[i][j] = -100;
114                }
115            }
116
117            string[] TabLog = new string[25];
118            for (int i = 0; i < 25; i++)
119            {
120                for (int j = 0; j < 25; j++)
121                {
122                    TabLog[i] += Convert.ToString(BigraphStatLog[i][j]) + "\t";                   
123                }
124            }
125            System.IO.File.WriteAllLines(@"H:\BS\BSLog100.txt", TabLog);
126
127            System.Xml.Serialization.XmlSerializer WriteBSLog = new System.Xml.Serialization.XmlSerializer(typeof(Double[][]));
128            System.Xml.XmlWriter XmlWriterLog = System.Xml.XmlWriter.Create(@"H:\BS\BSLog100.xml");
129            WriteBSLog.Serialize(XmlWriterLog, BigraphStatLog);
130            XmlWriterLog.Close();
131           
132
133        }
134    }
135
136
137    class Matrix
138    {
139        public char[,] Mat;
140        public static char[] Alphabet = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'K','L', 'M', 'N', 'O', 
141                                  'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
142        public Matrix()
143        {
144            Mat = new char[5,5];
145        }
146
147        public Matrix(char[,] matrix)
148        {
149            Mat = matrix;           
150        }       
151
152        public void ReadMatrixConsole()
153        {
154            string s;
155
156            for (int i = 0; i < 5; i += 1)
157            {
158                s = Console.In.ReadLine();
159                int pos = -1;
160
161                for (int j = 0; j < 5; j += 1)
162                {
163                    pos = s.IndexOfAny(Alphabet, pos + 1);
164                    Mat[i,j] = s[pos];
165                }
166            }
167        }
168
169        public void ReadMatrixFile(string Path)
170        {
171            string[] s = System.IO.File.ReadAllLines(Path);
172
173            for (int i = 0; i < 5; i++)
174                for (int j = 0; j < 5; j++)
175                    Mat[i, j] = s[i][j];
176        }
177
178        public int[] GetPosition(char Char)
179        {
180            for (int i = 0; i < 5; i += 1)
181            {
182                for (int j = 0; j < 5; j += 1)
183                {
184                    if (Char == Mat[i,j])
185                    {
186                        return new int[]{i,j};
187                    }
188                }
189            }
190            return null;
191        }
192
193        public void WriteOnConsole()
194        {
195            for (int i = 0; i < 5; i++)
196            {
197                for (int j = 0; j < 5; j++)
198                {                   
199                    Console.Out.Write(Mat[i, j] + " ");
200                }
201                Console.Out.WriteLine("");
202            }
203        }
204
205        public static void WriteOnConsoleInt(int[] matrix)
206        {           
207            for (int i = 0; i < 5; i++)
208            {
209                for (int j = 0; j < 5; j++)
210                {
211                    if (matrix[i * 5 + j] + 'A' < 'J')                       
212                        Console.Out.Write((char)(matrix[i * 5 + j] + 'A') + " ");
213                    else
214                        Console.Out.Write((char)(matrix[i * 5 + j] + 'B') + " "); 
215                }
216                Console.Out.WriteLine("");
217            }
218        }
219
220        public static char[,] ConvertToChar(int[] matrix)
221        {
222            char[,] matrixchar = new char[5, 5];           
223            for (int i = 0; i < 5; i++)
224            {
225                for (int j = 0; j < 5; j++)
226                {
227                    if (matrix[i * 5 + j] + 'A' < 'J')
228                        matrixchar[i, j] = (char)(matrix[i * 5 + j] + 'A');
229                    else
230                        matrixchar[i, j] = (char)(matrix[i * 5 + j] + 'B');                   
231                }               
232            }
233            return matrixchar;
234        }
235
236        public static int[] ConvertToInt(char[,] matrix)
237        {
238            int[] matrixint = new int[25];           
239            for (int i = 0; i < 5; i++)
240            {
241                for (int j = 0; j < 5; j++)
242                {
243                    if (matrix[i, j] < 'J')
244                        matrixint[i * 5 + j] = (int)(matrix[i, j] - 'A');
245                    else
246                        matrixint[i * 5 + j] = (int)(matrix[i, j] - 'B');
247                }
248            }
249            return matrixint;
250        }
251       
252    }
253
254
255    class PlayFair
256    {
257        static double[,] BigraphStat = new double[25, 25];
258        static double[,] CipherStat = new double[25, 25];   
259        static int[, ,] DecodingTab = new int[600, 2, 2];
260        static int DecodingTabLength;
261
262
263        public PlayFair()
264        {
265        }
266
267        public static string Encrypt(Matrix Key, string PlainText)
268        {
269            char Char1, Char2;
270            int RowChar1, RowChar2, ColumnChar1, ColumnChar2;
271            StringBuilder  CipherText = new StringBuilder(PlainText.Length / 2);
272
273            for (int i = 0; i < PlainText.Length; i += 2)
274            {
275                Char1 = PlainText[i];
276                Char2 = PlainText[i+1];
277
278                int[] pos1 = Key.GetPosition(Char1);
279                int[] pos2 = Key.GetPosition(Char2);
280               
281                RowChar1 = pos1[0];
282                ColumnChar1 = pos1[1]; 
283                RowChar2 = pos2[0];
284                ColumnChar2 = pos2[1];
285
286                if (RowChar1 == RowChar2)
287                {
288                    CipherText.Append(Key.Mat[RowChar1, (ColumnChar1 + 1) % 5]);
289                    CipherText.Append(Key.Mat[RowChar2, (ColumnChar2 + 1) % 5]);
290                }
291                else if (ColumnChar1 == ColumnChar2)
292                {
293                    CipherText.Append(Key.Mat[(RowChar1 + 1) % 5, ColumnChar1]);
294                    CipherText.Append(Key.Mat[(RowChar2 + 1) % 5, ColumnChar2]);
295                }
296                else
297                {
298                    CipherText.Append(Key.Mat[RowChar1, ColumnChar2]);
299                    CipherText.Append(Key.Mat[RowChar2, ColumnChar1]);
300                }
301
302            }
303
304            return CipherText.ToString();
305        }
306
307        public static string Decrypt(Matrix Key, string CipherText)
308        {
309            char Char1, Char2;
310            int RowChar1, RowChar2, ColumnChar1, ColumnChar2;
311            StringBuilder PlainText = new StringBuilder(CipherText.Length);
312
313            for (int i = 0; i < CipherText.Length; i += 2)
314            {
315                Char1 = CipherText[i];
316                Char2 = CipherText[i + 1];
317
318                int[] pos1 = Key.GetPosition(Char1);
319                int[] pos2 = Key.GetPosition(Char2);
320
321                RowChar1 = pos1[0];
322                ColumnChar1 = pos1[1];
323                RowChar2 = pos2[0];
324                ColumnChar2 = pos2[1];
325
326                if (RowChar1 == RowChar2)
327                {
328                    PlainText.Append(Key.Mat[RowChar1, (ColumnChar1 + 4) % 5]);
329                    PlainText.Append(Key.Mat[RowChar2, (ColumnChar2 + 4) % 5]);
330                }
331                else if (ColumnChar1 == ColumnChar2)
332                {
333                    PlainText.Append(Key.Mat[(RowChar1 + 4) % 5, ColumnChar1]);
334                    PlainText.Append(Key.Mat[(RowChar2 + 4) % 5, ColumnChar2]);
335                }
336                else
337                {
338                    PlainText.Append(Key.Mat[RowChar1, ColumnChar2]);
339                    PlainText.Append(Key.Mat[RowChar2, ColumnChar1]);
340                }
341
342            }
343
344            return PlainText.ToString();
345        }
346
347        public static string Format(string UnformattedText)
348        {
349            string PreformattedText;
350            StringBuilder FormattedText = new StringBuilder(UnformattedText.Length);
351           
352           
353            PreformattedText = UnformattedText.ToUpper();
354
355            for (int i = 0; i < PreformattedText.Length; i += 1)
356            {
357                if (PreformattedText[i] == 'J')
358                    FormattedText.Append("I");
359                else if (PreformattedText[i] > 64 && PreformattedText[i] < 91)
360                {
361                    FormattedText.Append(PreformattedText[i]);
362                }
363                else if (PreformattedText[i] == 'Ä')
364                    FormattedText.Append("AE");
365                else if (PreformattedText[i] == 'Ö')
366                    FormattedText.Append("OE");
367                else if (PreformattedText[i] == 'Ü')
368                    FormattedText.Append("UE");
369            }
370
371            int Length = FormattedText.Length;
372            for (int i = 0; i < Length - 1; i += 2)
373            {
374                if (FormattedText[i] == FormattedText[i + 1])
375                {
376                    FormattedText = FormattedText.Insert(i + 1, "X");
377                    Length += 1;
378                }
379            }
380
381            if ((FormattedText.Length % 2) == 1)
382            {
383                FormattedText.Append("X");
384            }
385
386            return FormattedText.ToString();
387        }
388
389        public static string Attack(string CipherText, Double[,] BS)
390        {
391            BigraphStat = BS;
392            BigraphStatistic CS = new BigraphStatistic();
393            CipherStat = CS.CalcLog(CipherText);
394            int KeyHeapLength = 5000;
395            int[] TestKey = new int[25];
396            double Score2;
397            int[] WorstKey = new int[25];
398            int[] BestKey = new int[25];
399            double WorstScore = 0;
400            double BestScore;
401            int Count = 0;
402
403
404            CalcDecodingTab(5);
405
406
407            //SortedDictionary<double, int[]> KeyHeap = new SortedDictionary<double, int[]>();           
408            //SortedDictionary<double, int[]>.KeyCollection KeyColl = KeyHeap.Keys;
409                       
410            PriorityQueue<int[], double>[] KeyHeap = new PriorityQueue<int[], double>[2];
411            KeyHeap[0] = new PriorityQueue<int[], double>();
412            KeyHeap[1] = new PriorityQueue<int[], double>();
413
414
415            Console.Write("Testing all partial keys of length 5 ");
416
417            DateTime time1 = DateTime.Now;
418
419            for (int i = 0; i < 25; i++)
420            {
421                Console.Write(".");
422                TestKey[0] = i;
423                for (int j = 0; j < 25; j++)               
424                    if (j != i)
425                    {
426                        TestKey[1] = j;
427                        for (int k = 0; k < 25; k++)
428                            if (k != i && k != j)
429                            {
430                                TestKey[2] = k;
431                                for (int l = 0; l < 25; l++)
432                                    if (l != i && l != j && l != k)
433                                    {
434                                        TestKey[3] = l;
435                                        for (int m = 0; m < 25; m++)
436                                            if (m != i && m != j && m != k && m != l)
437                                            {
438                                                TestKey[4] = m;
439                                                Score2 = EvaluateKey2(TestKey);
440                                                if (Count > KeyHeapLength-1)
441                                                {                                                   
442                                                    if (Score2 < WorstScore)
443                                                    {                                                       
444                                                        try
445                                                        {
446                                                            //if (!KeyHeap.Contains(Score2))
447                                                            {
448                                                                KeyHeap[0].Dequeue();                                                               
449                                                                KeyHeap[0].Enqueue((int[]) TestKey.Clone(), Score2);
450                                                                WorstScore = KeyHeap[0].Peek().Priority;
451                                                            }
452                                                        }
453                                                        catch (ArgumentException)
454                                                        {
455                                                            Console.Out.WriteLine("Wert bereits im Heap (> {0})", KeyHeapLength);
456                                                        }                                                       
457                                                    }
458                                                }
459                                                else
460                                                {
461                                                    try
462                                                    {
463                                                        KeyHeap[0].Enqueue(TestKey, Score2);
464                                                        WorstScore = Math.Max(WorstScore, Score2);
465                                                        Count = KeyHeap[0].Count;
466                                                    }
467                                                    catch (ArgumentException)
468                                                    {
469                                                        Console.Out.WriteLine("Wert bereits im Heap (< {0})", KeyHeapLength);
470                                                    }
471                                                }                                               
472                                            }
473                                    }
474                            }
475                    }               
476            }
477
478
479            DateTime time2 = DateTime.Now;
480            TimeSpan diff = time2 - time1;
481            Console.Out.WriteLine("\n\ntime required: " + Convert.ToString(diff.TotalSeconds) + " seconds");           
482                                         
483                                   
484            WorstKey = KeyHeap[0].Peek().Value;
485            BestScore = double.MaxValue;
486            foreach (PriorityQueueItem<int[], double> pqi in KeyHeap[0])
487            {
488                if (pqi.Priority < BestScore)
489                {
490                    BestScore = pqi.Priority;
491                    BestKey = pqi.Value;
492                }
493            }
494           
495            Console.Out.WriteLine("\nBest Score: {0}", BestScore);
496            Console.Out.WriteLine("Best Key:");
497            Matrix.WriteOnConsoleInt(BestKey);
498
499
500            Console.Out.WriteLine("\nWorst Score: {0}", WorstScore);
501            Console.Out.WriteLine("Worst Key:");
502            Matrix.WriteOnConsoleInt(WorstKey);
503
504                                 
505            Console.Out.WriteLine("\nAmount of keys in Heap: {0}", KeyHeap[0].Count);
506
507            Console.Out.WriteLine("\nTesting next position of keys in heap...");
508
509            time1 = DateTime.Now;
510           
511            for (int pos = 5; pos < 25; pos++)
512            {
513                KeyHeap[pos % 2].Clear();
514                CalcDecodingTab(pos + 1);
515                Count = 0;
516               
517                foreach (PriorityQueueItem<int[], double> pqi in KeyHeap[(pos + 1) % 2])
518                {
519                    bool[] letterinkey = new bool[25];
520                    for (int i = 0; i < pos; i++)
521                    {
522                        letterinkey[pqi.Value[i]] = true;
523                    }
524                    for (int i = 0; i < 25; i++)
525                    {
526                        if (!letterinkey[i])
527                        {
528                            pqi.Value[pos] = i;
529                            Score2 = EvaluateKey2(pqi.Value);
530                            if (Count > KeyHeapLength-1)
531                            {
532                                if (Score2 < WorstScore)
533                                {
534                                    KeyHeap[pos % 2].Dequeue();
535                                    KeyHeap[pos % 2].Enqueue((int[])pqi.Value.Clone(), Score2);
536                                    WorstScore = KeyHeap[pos % 2].Peek().Priority;
537                                }
538                            }
539                            else
540                            {
541                                KeyHeap[pos % 2].Enqueue(pqi.Value, Score2);
542                                WorstScore = Math.Max(WorstScore, Score2);
543                                Count = KeyHeap[pos % 2].Count;
544                            }
545                        }
546                    }
547                }
548                Console.Out.WriteLine("Position {0} done.", pos);
549            }
550
551
552            time2 = DateTime.Now;
553            diff = time2 - time1;
554            Console.Out.WriteLine("\ntime required: " + Convert.ToString(diff.TotalSeconds) + " seconds");   
555
556
557            BestScore = double.MaxValue;
558
559            foreach (PriorityQueueItem<int[], double> pqi in KeyHeap[24 % 2])
560            {
561                if (pqi.Priority < BestScore)
562                {
563                    BestScore = pqi.Priority;
564                    BestKey = (int[])pqi.Value.Clone();
565                }
566            }
567
568            Console.Out.WriteLine("\nBest Score: {0}", BestScore);
569            Console.Out.WriteLine("Best Key: ");
570            Matrix.WriteOnConsoleInt(BestKey);
571
572            int[] CorrectKey = new int[25];
573            for (int i = 0; i < 25; i++)
574                CorrectKey[i] = i;
575            Console.Out.WriteLine("\nCorrect Key Score: {0}", EvaluateKey2(CorrectKey));
576            Console.Out.WriteLine("Correct Key: ");
577            Matrix.WriteOnConsoleInt(CorrectKey);
578
579
580            Matrix BestKeyMatrix = new Matrix(Matrix.ConvertToChar(BestKey));
581           
582            return Decrypt(BestKeyMatrix, CipherText);
583        }
584
585        public static Double EvaluateKey(int[] Key)
586        {
587            double Mean = 0;
588            int MeanLength = 0;
589            double SumProbCipher = 0;
590            int BigraphsInCipher = 0;
591            double Score = 0;
592
593            for (int i = 0; i < DecodingTabLength; i++)
594            {
595                if (BigraphStat[Key[DecodingTab[i, 1, 0]], Key[DecodingTab[i, 1, 1]]] > -9)
596                {
597                    Mean += BigraphStat[Key[DecodingTab[i, 1, 0]], Key[DecodingTab[i, 1, 1]]];
598                    MeanLength++;
599                }
600                if (CipherStat[Key[DecodingTab[i, 0, 0]], Key[DecodingTab[i, 0, 1]]] > -100)
601                {
602                    SumProbCipher += CipherStat[Key[DecodingTab[i, 0, 0]], Key[DecodingTab[i, 0, 1]]];
603                    BigraphsInCipher++;
604                }
605            }
606
607            //Console.Out.WriteLine("Summe der " + Convert.ToString(MeanLength) + " allg. Wahrsch. > -9 : " + Convert.ToString(Mean));
608            Mean /= MeanLength;
609
610            //Console.Out.WriteLine("Durchschnitt: " + Convert.ToString(Mean));
611
612            //Console.Out.WriteLine("Summe der " + Convert.ToString(BigraphsInCipher) + " Wahrsch. > -100 im Ciphertext: " + Convert.ToString(SumProbCipher));
613
614            Score = SumProbCipher - BigraphsInCipher * Mean;
615
616            //Console.Out.WriteLine("Score: " + Convert.ToString(Score));
617
618            return Score;
619        }
620
621        public static Double EvaluateKey2(int[] Key)
622        {
623            Double Score2 = 0;           
624
625            for (int i = 0; i < DecodingTabLength; i++)
626            {
627                //if (BigraphStat[Key[DecodingTab[i, 1, 0]], Key[DecodingTab[i, 1, 1]]] > -11)
628                Score2 += Math.Abs(BigraphStat[Key[DecodingTab[i, 1, 0]], Key[DecodingTab[i, 1, 1]]] - CipherStat[Key[DecodingTab[i, 0, 0]], Key[DecodingTab[i, 0, 1]]]);
629            }                     
630
631            return Score2;
632        }
633
634        public static int[, ,] CalcDecodingTab(int KeyLength)
635        {           
636            int index = 0;
637
638            for (int i = 0; i < KeyLength - 1; i++)
639            {
640                for (int j = i + 1; j < KeyLength; j++)
641                {
642                    if ((i / 5) == (j / 5))     // i and j in same row
643                    {
644                        if ((i % 5) > 0)
645                        {
646                            DecodingTab[index, 0, 0] = i;
647                            DecodingTab[index, 0, 1] = j;
648                            DecodingTab[index, 1, 0] = i - 1;
649                            DecodingTab[index, 1, 1] = j - 1;
650                            index++;
651                            DecodingTab[index, 0, 0] = DecodingTab[index-1, 0, 1];
652                            DecodingTab[index, 0, 1] = DecodingTab[index-1, 0, 0];
653                            DecodingTab[index, 1, 0] = DecodingTab[index-1, 1, 1];
654                            DecodingTab[index, 1, 1] = DecodingTab[index-1, 1, 0];
655                            index++;
656                        }
657                        else if (i + 4 < KeyLength)
658                        {
659                            DecodingTab[index, 0, 0] = i;
660                            DecodingTab[index, 0, 1] = j;
661                            DecodingTab[index, 1, 0] = i + 4;
662                            DecodingTab[index, 1, 1] = j - 1;
663                            index++;
664                            DecodingTab[index, 0, 0] = DecodingTab[index - 1, 0, 1];
665                            DecodingTab[index, 0, 1] = DecodingTab[index - 1, 0, 0];
666                            DecodingTab[index, 1, 0] = DecodingTab[index - 1, 1, 1];
667                            DecodingTab[index, 1, 1] = DecodingTab[index - 1, 1, 0];
668                            index++;
669                        }
670                    }
671
672                    else if ((i % 5) == (j % 5))      // i and j in same column
673                    {
674                        if ((i / 5) > 0)
675                        {
676                            DecodingTab[index, 0, 0] = i;
677                            DecodingTab[index, 0, 1] = j;
678                            DecodingTab[index, 1, 0] = i - 5;
679                            DecodingTab[index, 1, 1] = j - 5;
680                            index++;
681                            DecodingTab[index, 0, 0] = DecodingTab[index - 1, 0, 1];
682                            DecodingTab[index, 0, 1] = DecodingTab[index - 1, 0, 0];
683                            DecodingTab[index, 1, 0] = DecodingTab[index - 1, 1, 1];
684                            DecodingTab[index, 1, 1] = DecodingTab[index - 1, 1, 0];
685                            index++;
686                        }
687                        else if ((i + 20) < KeyLength)
688                        {
689                            DecodingTab[index, 0, 0] = i;
690                            DecodingTab[index, 0, 1] = j;
691                            DecodingTab[index, 1, 0] = i + 20;
692                            DecodingTab[index, 1, 1] = j - 5;
693                            index++;
694                            DecodingTab[index, 0, 0] = DecodingTab[index - 1, 0, 1];
695                            DecodingTab[index, 0, 1] = DecodingTab[index - 1, 0, 0];
696                            DecodingTab[index, 1, 0] = DecodingTab[index - 1, 1, 1];
697                            DecodingTab[index, 1, 1] = DecodingTab[index - 1, 1, 0];
698                            index++;
699                        }
700                    }
701                    else if ((i / 5) * 5 + (j % 5) < KeyLength && (j / 5) * 5 + (i % 5) < KeyLength)   // i and j in a square
702                    {   
703                        DecodingTab[index, 0, 0] = i;
704                        DecodingTab[index, 0, 1] = j;
705                        DecodingTab[index, 1, 0] = (i / 5) * 5 + (j % 5);
706                        DecodingTab[index, 1, 1] = (j / 5) * 5 + (i % 5);
707                        index++;
708                        DecodingTab[index, 0, 0] = DecodingTab[index - 1, 0, 1];
709                        DecodingTab[index, 0, 1] = DecodingTab[index - 1, 0, 0];
710                        DecodingTab[index, 1, 0] = DecodingTab[index - 1, 1, 1];
711                        DecodingTab[index, 1, 1] = DecodingTab[index - 1, 1, 0];
712                        index++;                       
713                    }
714
715                }
716            }
717
718            DecodingTabLength = index;
719            return DecodingTab;
720        }
721
722    }
723
724}
Note: See TracBrowser for help on using the repository browser.