source: trunk/CrypPlugins/TranspositionAnalyser/TranspositionAnalyser.cs @ 1475

Last change on this file since 1475 was 1475, checked in by weyers, 12 years ago

TranspositionAnalyser analyse by crib first steps,PermutationGenerator extended

File size: 66.4 KB
Line 
1using System;
2using System.Linq;
3using System.Text;
4using Cryptool.PluginBase.Analysis;
5using Cryptool.PluginBase;
6using System.Windows.Controls;
7using System.ComponentModel;
8using Cryptool.PluginBase.Control;
9using Cryptool.PluginBase.Miscellaneous;
10using System.Collections;
11using System.Windows.Threading;
12using System.Threading;
13using System.Collections.Generic;
14
15
16
17namespace TranspositionAnalyser
18{
19
20    [Author("Daniel Kohnen, Julian Weyers, Simon Malischewski, Armin Wiefels", "kohnen@cryptool.org, weyers@cryptool.org, malischewski@cryptool.org, wiefels@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
21    [PluginInfo(false, "Transposition Analyser", "Bruteforces the columnar transposition.", "TranspositionAnalyser/Description/TADescr.xaml", "TranspositionAnalyser/Images/icon.png")]
22    public class TranspositionAnalyser : IAnalysisMisc
23    {
24        private enum ReadInMode { byRow = 0, byColumn = 1 };
25        private enum PermutationMode { byRow = 0, byColumn = 1 };
26        private enum ReadOutMode { byRow = 0, byColumn = 1 };
27        private byte[] crib;
28        private byte[] input;
29        private Queue valuequeue;
30        LinkedList<ValueKey> list1;
31        private TranspositionAnalyserQuickWatchPresentation myPresentation;
32        private Random rd;
33        private AutoResetEvent ars;
34
35        TranspositionAnalyserSettings settings;
36        #region Properties
37        [PropertyInfo(Direction.InputData, "Input", "Input data for Analysis", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
38        public Byte[] Input
39        {
40            get
41            {
42                return this.input;
43            }
44
45            set
46            {
47                this.input = value;
48                OnPropertyChange("Input");
49
50            }
51        }
52
53        [PropertyInfo(Direction.InputData, "Crib", "Crib input", "Crib for Analysis", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
54        public Byte[] Crib
55        {
56            get
57            {
58                return this.crib;
59            }
60
61            set
62            {
63                this.crib = value;
64                OnPropertyChange("Crib");
65            }
66        }
67
68
69
70        #endregion
71        /// <summary>
72        /// Constructor
73        /// </summary>
74        public TranspositionAnalyser()
75        {
76            settings = new TranspositionAnalyserSettings();
77            myPresentation = new TranspositionAnalyserQuickWatchPresentation();
78            QuickWatchPresentation = myPresentation;
79            myPresentation.doppelClick += new EventHandler(this.doppelClick);
80            ars = new AutoResetEvent(false);
81        }
82
83        private void doppelClick(object sender, EventArgs e)
84        {
85            ListViewItem lvi = sender as ListViewItem;
86            ResultEntry rse = lvi.Content as ResultEntry;
87            Output = System.Text.Encoding.GetEncoding(1252).GetBytes(rse.Text);
88        }
89
90        private IControlEncryption controlMaster;
91        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.None, null)]
92        public IControlEncryption ControlMaster
93        {
94
95            get { return controlMaster; }
96            set
97            {
98                // value.OnStatusChanged += onStatusChanged;
99                controlMaster = value;
100                OnPropertyChanged("ControlMaster");
101            }
102        }
103
104     
105
106        private IControlCost costMaster;
107        [PropertyInfo(Direction.ControlMaster, "Cost Master", "Used for cost calculation", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.None, null)]
108        public IControlCost CostMaster
109        {
110            get { return costMaster; }
111            set
112            {
113                costMaster = value;
114            }
115        }
116
117        private byte[] output;
118        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
119        public byte[] Output
120        {
121            get
122            {
123                return this.output;
124            }
125            set
126            {
127                this.output = value;
128                OnPropertyChanged("Output");
129            }
130        }
131
132        public void GuiLogMessage(string message, NotificationLevel loglevel)
133        {
134            if (OnGuiLogNotificationOccured != null)
135                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, loglevel));
136        }
137
138        #region IPlugin Member
139
140        public event Cryptool.PluginBase.StatusChangedEventHandler OnPluginStatusChanged;
141
142        public event Cryptool.PluginBase.GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
143
144        public event Cryptool.PluginBase.PluginProgressChangedEventHandler OnPluginProgressChanged;
145
146        public ISettings Settings
147        {
148            get { return settings; }
149        }
150
151        public UserControl Presentation
152        {
153            get { return null; }
154        }
155
156        public UserControl QuickWatchPresentation
157        {
158            get;
159            private set;
160        }
161
162        public void PreExecution()
163        {
164
165        }
166
167        public void Execute()
168        {
169
170
171            if (this.input != null)
172            {
173                if (this.ControlMaster != null && this.input != null)
174                    this.process(this.ControlMaster);
175                else
176                {
177                    GuiLogMessage("You have to connect the Transposition Plugin to the Transpostion Analyzer Control!", NotificationLevel.Warning);
178                }
179            }
180            ProgressChanged(1, 1);
181        }
182
183        public void PostExecution()
184        {
185
186        }
187
188        public void Pause()
189        {
190
191        }
192
193        private Boolean stop;
194        public void Stop()
195        {
196            ars.Set();
197            stop = true;
198        }
199
200        public void Initialize()
201        {
202            this.settings.Analysis_method = 0;
203        }
204
205        public void Dispose()
206        {
207
208        }
209
210        private void onStatusChanged(IControl sender, bool readyForExecution)
211        {
212
213        }
214
215        public void OnPropertyChanged(string name)
216        {
217            if (PropertyChanged != null)
218            {
219                PropertyChanged(this, new PropertyChangedEventArgs(name));
220            }
221        }
222
223        private void OnPropertyChange(String propertyname)
224        {
225            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
226        }
227
228        public void process(IControlEncryption sender)
229        {
230            if (input != null)
231            {
232                switch (this.settings.Analysis_method)
233                {
234                    case 0: Output = costfunction_bruteforce(sender); GuiLogMessage("Starting Brute-Force Analysis", NotificationLevel.Info); break;
235                    case 1: GuiLogMessage("Starting Analysis with crib", NotificationLevel.Info); cribAnalysis(sender, this.crib, this.input); break;
236                    case 2: GuiLogMessage("Starting genetic analysis", NotificationLevel.Info); geneticAnalysis(sender); break;
237                }
238            }
239            else
240            {
241                GuiLogMessage("No Input!", NotificationLevel.Error);
242            }
243
244
245        }
246
247        private int[] getBruteforceSettings()
248        {
249            int[] set;
250            int sum = 0;
251            if (settings.ColumnColumnColumn) sum++;
252            if (settings.ColumnColumnRow) sum++;
253            if (settings.RowColumnColumn) sum++;
254            if (settings.RowColumnRow) sum++;
255
256            if (sum > 0)
257            {
258                set = new int[sum];
259                int count = 0;
260                if (settings.ColumnColumnColumn)
261                {
262                    set[count] = 0;
263                    count++;
264                }
265                if (settings.ColumnColumnRow)
266                {
267                    set[count] = 1;
268                    count++;
269                }
270                if (settings.RowColumnColumn)
271                {
272                    set[count] = 2;
273                    count++;
274                }
275
276                if (settings.RowColumnRow)
277                {
278                    set[count] = 3;
279                    count++;
280                }
281                return set;
282            }
283            else
284            {
285                return null;
286            }
287
288        }
289
290        private byte[] costfunction_bruteforce(IControlEncryption sender)
291        {
292            valuequeue = Queue.Synchronized(new Queue());
293            int[] set = getBruteforceSettings();
294            stop = false;
295            if (sender != null && costMaster != null && set != null)
296            {
297                GuiLogMessage("start", NotificationLevel.Info);
298                double best = Double.MinValue;
299
300                if (costMaster.getRelationOperator() == RelationOperator.LessThen)
301                {
302                    best = Double.MaxValue;
303                }
304
305                list1 = getDummyLinkedList(best);
306                String best_text = "";
307                ArrayList list = null;
308
309               
310                //Just for fractional-calculation:
311                PermutationGenerator per = new PermutationGenerator(2);
312                DateTime starttime = DateTime.Now;
313                DateTime lastUpdate = DateTime.Now;
314
315                int max = 0;
316                max = settings.MaxLength;
317                //GuiLogMessage("Max: " + max, NotificationLevel.Info);
318                if (max > 1 && max < 21)
319                {
320                    long size = 0;
321                    for (int i = 2; i <= max; i++)
322                    {
323                        size = size + per.getFactorial(i);
324                    }
325                    size = size * set.Length;
326                    long sum = 0;
327                    for (int i = 1; i <= max; i++)
328                    {
329                        // for every selected bruteforce mode:
330                        for (int s = 0; s < set.Length; s++)
331                        {
332                            switch (set[s])
333                            {
334                                case (0):
335                                    controlMaster.changeSettings("ReadIn", ReadInMode.byColumn);
336                                    controlMaster.changeSettings("Permute", PermutationMode.byColumn);
337                                    controlMaster.changeSettings("ReadOut", ReadOutMode.byColumn);
338                                    break;
339                                case (1):
340                                    controlMaster.changeSettings("ReadIn", ReadInMode.byColumn);
341                                    controlMaster.changeSettings("Permute", PermutationMode.byColumn);
342                                    controlMaster.changeSettings("ReadOut", ReadOutMode.byRow);
343                                    break;
344                                case (2):
345                                    controlMaster.changeSettings("ReadIn", ReadInMode.byRow);
346                                    controlMaster.changeSettings("Permute", PermutationMode.byColumn);
347                                    controlMaster.changeSettings("ReadOut", ReadOutMode.byColumn);
348                                    break;
349                                case (3):
350                                    controlMaster.changeSettings("ReadIn", ReadInMode.byRow);
351                                    controlMaster.changeSettings("Permute", PermutationMode.byColumn);
352                                    controlMaster.changeSettings("ReadOut", ReadOutMode.byRow);
353                                    break;
354                            }
355
356                            per = new PermutationGenerator(i);
357
358                            while (per.hasMore() && !stop)
359                            {
360                                best = list1.Last.Value.value;
361                                int[] key = per.getNext();
362                                byte[] b = new byte[key.Length];
363                                for (int j = 0; j < b.Length; j++)
364                                {
365                                    b[j] = Convert.ToByte(key[j]);
366                                }
367                                byte[] dec = sender.Decrypt(input, b, null);
368                                if (dec != null)
369                                {
370                                    double val = costMaster.calculateCost(dec);
371                                    if (val.Equals(new Double()))
372                                    {
373                                        return new byte[0];
374                                    }
375                                    if (costMaster.getRelationOperator() == RelationOperator.LessThen)
376                                    {
377                                        if (val <= best)
378                                        {
379                                            ValueKey valkey = new ValueKey();
380                                            String keyStr = "";
381                                            foreach (int xyz in key)
382                                            {
383                                                keyStr += xyz +", ";
384                                            }
385                                            valkey.decryption = dec;
386                                            valkey.key = keyStr;
387                                            valkey.value = val;
388                                            valuequeue.Enqueue(valkey);
389                                        }
390                                    }
391                                    else
392                                    {
393                                        if (val >= best)
394                                        {
395                                            ValueKey valkey = new ValueKey();
396                                            String keyStr = "";
397                                            foreach (int xyz in key)
398                                            {
399                                                keyStr += xyz;
400                                            }
401                                            valkey.decryption = dec;
402                                            valkey.key = keyStr;
403                                            valkey.value = val;
404                                            valuequeue.Enqueue(valkey);
405                                        }
406                                    }
407                                }
408
409                                sum++;
410                                if (DateTime.Now >= lastUpdate.AddMilliseconds(1000))
411                                {
412                                    updateToplist(list1);
413                                    showProgress(starttime, size, sum);
414                                    ProgressChanged(sum, size);
415                                    lastUpdate = DateTime.Now;
416                                }
417                            }
418                        }
419                    }
420                    if (list != null)
421                    {
422                        int i = 1;
423                        foreach (string tmp in list)
424                        {
425                            GuiLogMessage("ENDE (" + i++ + ")" + best + ": " + tmp, NotificationLevel.Info);
426                        }
427                    }
428                    else
429                    {
430                        GuiLogMessage("ENDE " + best + ": " + best_text, NotificationLevel.Info);
431                    }
432                    return list1.First.Value.decryption;
433                }
434                else
435                {
436                    GuiLogMessage("Error: Check transposition bruteforce length. Max length is 20!", NotificationLevel.Error);
437                    return null;
438                }
439            }
440            else
441            {
442                GuiLogMessage("Error: No costfunction applied.", NotificationLevel.Error);
443                return null;
444            }
445        }
446
447        private LinkedList<ValueKey> getDummyLinkedList(double best)
448        {
449            ValueKey valueKey = new ValueKey();
450            valueKey.value = best;
451            valueKey.key = "dummykey";
452            valueKey.decryption = new byte[0];
453            LinkedList<ValueKey> list = new LinkedList<ValueKey>();
454            LinkedListNode<ValueKey> node = list.AddFirst(valueKey);
455            for (int i = 0; i < 9; i++)
456            {
457                node = list.AddAfter(node, valueKey);
458            }
459            return list;
460        }
461
462        private void updateToplist(LinkedList<ValueKey> costList)
463        {
464            LinkedListNode<ValueKey> node;
465            while (valuequeue.Count != 0)
466            {
467                ValueKey vk = (ValueKey)valuequeue.Dequeue();
468                if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
469                {
470                    if (vk.value > costList.Last().value)
471                    {
472                        node = costList.First;
473                        int i = 0;
474                        while (node != null)
475                        {
476                            if (vk.value > node.Value.value)
477                            {
478                                costList.AddBefore(node, vk);
479                                costList.RemoveLast();
480                                if (i == 0)
481                                {
482                                    Output = vk.decryption;
483                                }
484                                // value_threshold = costList.Last.Value.value;
485                                break;
486                            }
487                            node = node.Next;
488                            i++;
489                        }//end while
490                    }//end if
491                }
492                else
493                {
494                    if (vk.value < costList.Last().value)
495                    {
496                        node = costList.First;
497                        int i = 0;
498                        while (node != null)
499                        {
500                            if (vk.value < node.Value.value)
501                            {
502                                costList.AddBefore(node, vk);
503                                costList.RemoveLast();
504                                if (i == 0)
505                                {
506                                    Output = vk.decryption;
507                                }
508
509                                // value_threshold = costList.Last.Value.value;
510                                break;
511                            }
512                            node = node.Next;
513                            i++;
514                        }//end while
515                    }//end if
516                }
517            }
518        }
519
520        #endregion
521
522        #region INotifyPropertyChanged Member
523
524        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
525
526        #endregion
527
528        public void ProgressChanged(double value, double max)
529        {
530            if (OnPluginProgressChanged != null)
531            {
532                OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
533
534            }
535        }
536
537        #region cribAnalysis
538
539        private List<Dingens> tablelist;
540        public void cribAnalysis(IControlEncryption sender, byte[] crib, byte[] cipher)
541        {
542           
543
544            if (crib != null && crib != null)
545            {
546                foreach (int c in getKeyLength(crib, cipher))
547                {
548                    GuiLogMessage("Possible Key-Length: " + c, NotificationLevel.Info);
549                }
550            }
551            else { GuiLogMessage("Missing crib or input!", NotificationLevel.Info); }
552
553            // tmp-
554            // ValueKey Liste list
555            // für jeden Text einen ValueKey erstellen
556            // Bsp:
557            //ValueKey tmpValue = new ValueKey();
558            //tmpValue.keyArray = key;
559            //byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
560            //double val = costMaster.calculateCost(dec);
561
562            // Am Ende Liste von ValueKeys an update geben:
563            // updateToplist(list);
564
565            //  if (costMaster.getRelationOperator() == RelationOperator.LessThen)
566
567            ValueKey tmpValue = new ValueKey();
568            tablelist = new List<Dingens>();
569            //tmpValue.keyArray = {2;3;4};
570            //byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
571            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
572            //String one = "ZWYXTENTEISECHICHTIGEXSITEERHEITSMITLLILUNGXANXADEEXAGENTENXXSSXINTERNENDIICHERHEITSXWENSTESYXESELERDENXDOPPXDAGENTENXINXRENXEIGENENUTEIHENXVERMDZETYXESXWIRSTURXAEUSSERTXENXVORSICHGXBEIMXUMGANHEMITXSICHERTEITSRELEVANXAMXMATERIALXINGEHALTENYERMXRAHMENXDAGXMAULWURFJXSDXWIRDXDIESTICHERHEITSLLUFEXAUFXSIGEYCONXDREIXXESETZTYXDERGSRSTEXZUGANXISCHLUESSELONSTXDIFFUSITXYXABXSOFORICWIRDXZURXSXKHERUNGXDERONOMMUNIKATINAXDASXALTEROSTIVEXKRYPTRAYSTEMXCAETG";
573            String two = "YXTENTEISEZWICHTIGEXSICHERHEITSMITTEILUNGXANXALLEXAGENTENXDESXINTERNENXSICHERHEITSDIENSTESYXESXWERDENXDOPPELAGENTENXINXDENXEIGENENXREIHENXVERMUTETYXESXWIRDZURXAEUSSERSTENXVORSICHTXBEIMXUMGANGXMITXSICHERHEITSRELEVANTEMXMATERIALXANGEHALTENYXIMXRAHMENXDERXMAULWURFJAGDXWIRDXDIEXSICHERHEITSSTUFEXAUFXSILLYCONXDREIXGESETZTYXDERXERSTEXZUGANGSSCHLUESSELXISTXDIFFUSIONYXABXSOFORTXWIRDXZURXSICHERUNGXDERXKOMMUNIKATIONXDASXALTERNATIVEXKRYPTOSYSTEMXCAETRAG";
574            //double val = costMaster.calculateCost(Input);
575            double val2 = costMaster.calculateCost(enc.GetBytes(two));
576            if (costMaster.getRelationOperator() == RelationOperator.LessThen)
577            {
578                GuiLogMessage(enc.GetString(crib), NotificationLevel.Debug);
579            }
580           
581            PermutationGenerator per = new PermutationGenerator(2);
582            cribAnalysis1(Crib, Input);
583            ars.WaitOne();
584
585            for (int i = 0; i < tablelist.Count; i++) 
586            {
587                for (int ix = 0; ix < tablelist[i].getCount();ix++ )
588                {
589                    if (tablelist[i].getSize(ix) == 0)
590                    {
591                        tablelist.Remove(tablelist[i]);
592                        i--;
593                        break;
594                       
595                    }
596                }
597            }
598            for (int i = 0; i < tablelist.Count; i++)
599            {
600                GuiLogMessage(tablelist[i].getCount()+"Kawumm", NotificationLevel.Debug);
601            }
602
603            //int[,] key = { { 1, 0, 0 }, { 2, 0, 0 }, { 3, 0, 0 }, { 6, 0, 0 }, { 4, 8, 11 }, { 12, 12, 0 }, { 10, 0, 0 }, { 4, 8, 11 }, { 7, 8, 11 }, { 5, 0, 0 }, { 8, 9, 0 }, { 8, 9, 0 } };
604            LinkedList<ValueKey> valList = new LinkedList<ValueKey>();
605            for (int x = 0; x < tablelist.Count; x++)
606            {
607                int[,] key = tablelist[x].toint();
608
609                List<List<int>> final1 = per.returnlogicper(key);
610               
611
612                for (int ix = 0; ix < final1.Count; ix++)
613                {
614                    for (int iy = 0; iy < final1[ix].Count; iy++)
615                    {
616                        int[] key2 = final1[ix].ToArray();
617                        byte[] key3 = new byte[key2.Length];
618                        for (int i = 0; i < key2.Length; i++)
619                        {
620                            key3[i] = Convert.ToByte(key2[i]);
621                        }
622                        byte[] dec = sender.Decrypt(Input, key3, null);
623                        GuiLogMessage(enc.GetString(dec), NotificationLevel.Debug);
624                        double val3 = costMaster.calculateCost(dec);
625
626                        ValueKey v = new ValueKey();
627                        v.decryption = dec;
628                        v.value = val3;
629                        v.key = "";
630                        v.keyArray = key3;
631                        valList.AddFirst(v);
632                       
633                       
634                        GuiLogMessage("" + val3, NotificationLevel.Debug);
635                        int help = final1[ix][0];
636                        final1[ix].Remove(final1[ix][0]);
637                        final1[ix].Add(help);
638
639                    }
640                }
641            }
642
643           // GuiLogMessage(""+val, NotificationLevel.Debug);
644           
645            GuiLogMessage("" + val2, NotificationLevel.Debug);
646
647            // Am Ende Liste von ValueKeys an update geben:
648           
649            double best = Double.MinValue;
650            list1 = getDummyLinkedList(best);
651            valuequeue = Queue.Synchronized(new Queue());
652            foreach (ValueKey v in valList)
653            {
654                valuequeue.Enqueue(v);
655            }
656            list1 = valList;
657            updateToplist(valList);
658            showProgress(System.DateTime.Now, 1, 1);
659            ProgressChanged(1, 1);           
660
661            //  if (costMaster.getRelationOperator() == RelationOperator.LessThen)
662
663
664        }
665
666        private void cribAnalysis(byte[] crib, byte[] cipher)
667        {
668
669            if (crib != null && crib != null)
670            {
671                foreach (int c in getKeyLength(crib, cipher))
672                {
673                    Console.WriteLine("Possible Key-Length: " + c);
674                }
675            }
676            else { Console.WriteLine("Missing crib or input!"); }
677        }
678
679        private void cribAnalysis1(byte[] crib, byte[] cipher)
680        {
681            if (crib == null || cipher == null)
682            {
683                Console.WriteLine("Crib or Cipher NULL");
684                return;
685            }
686
687            for (int keylength = 1; keylength < crib.Length; keylength++)
688            {
689                byte[,] cipherM = cipherToMatrix(keylength, cipher);
690                byte[,] cribM = cribToMatrix(keylength, crib);
691
692                // Matrix in Console zeigen
693                if (keylength == 12)
694                {
695                    int length = cipherM.Length / keylength;
696                    System.Text.Encoding enc = System.Text.Encoding.ASCII;
697                    for (int a = 0; a < keylength; a++)
698                    {
699
700                        for (int b = 0; b < length; b++)
701                        {
702                            if (cipherM[b, a] != null)
703                                Console.Write((char)cipherM[b, a]);
704                        }
705                        Console.WriteLine("");
706                    }
707                    Console.WriteLine("");
708                }
709
710                analyse1(keylength, cipherM, cribM);
711            }
712        }
713
714        private void analyse1(int keylength, byte[,] cipherMatrix, byte[,] cribMatrix)
715        {
716            int cipherMatrixLength = cipherMatrix.Length / keylength;
717            int cribMatrixHeight = cribMatrix.Length / keylength;
718
719            ArrayList all = new ArrayList();
720            Boolean found = true;
721
722
723            int end = keylength;
724            if (cribMatrixHeight > 1)
725            {
726                byte newbyte = new byte();
727                for (int i = 0; i < keylength; i++)
728                {
729                    if (cribMatrix[i, 1] == newbyte)
730                    {
731                        end = i;
732                        break;
733                    }
734                }
735            }
736
737
738            for (int x = 0; x < end; x++)
739            {
740                ArrayList c = contains(x, keylength, cipherMatrix, cribMatrix);
741                if (c == null)
742                {
743                    found = false;
744                    break;
745                }
746                else
747                {
748                    foreach (MiniCribPos m in c)
749                    {
750                        all.Add(m);
751                    }
752                }
753            }
754
755            if (found == false)
756            {
757                return;
758            }
759
760            else
761            {
762                auswertenNeu(keylength, end, all, cribMatrix, cipherMatrix);
763            }
764
765        }
766
767        private ArrayList contains(int cribColumn, int keylength, byte[,] cipherMatrix, byte[,] cribMatrix)
768        {
769            int cipherMatrixLength = cipherMatrix.Length / keylength;
770            int cribMatrixHeight = cribMatrix.Length / keylength;
771            byte newbyte = new byte();
772
773            ArrayList allFound = null;
774
775            for (int a = 0; a < keylength; a++)
776            {
777                for (int b = 0; b < cipherMatrixLength; b++)
778                {
779                    if (cribMatrix[cribColumn, 0].Equals(cipherMatrix[b, a]))
780                    {
781                        for (int y = 1; y < cribMatrixHeight; y++)
782                        {
783                            if (b + y < cipherMatrixLength)
784                            {
785                                if (cribMatrix[cribColumn, y].Equals(newbyte))
786                                {
787                                    //passendes gefunden und jetzt eintragen
788                                    MiniCribPos found = new MiniCribPos(cribColumn, b, a);
789
790                                    if (allFound == null)
791                                    {
792                                        allFound = new ArrayList();
793                                    }
794
795                                    allFound.Add(found);
796
797
798                                }
799
800                                else if (cribMatrix[cribColumn, y].Equals(cipherMatrix[b + y, a]))
801                                {
802                                    if (y == cribMatrixHeight - 1)
803                                    {
804                                        //passendes gefunden und jetzt eintragen
805                                        MiniCribPos found = new MiniCribPos(cribColumn, b, a);
806
807                                        if (allFound == null)
808                                        {
809                                            allFound = new ArrayList();
810                                        }
811
812                                        allFound.Add(found);
813                                    }
814                                }
815                                else
816                                {
817                                    break;
818                                }
819                            }
820                            else
821                            {
822                                break;
823                            }
824                        }
825                    }
826                }
827            }
828            return allFound;
829        }
830
831        // found possible keylength with crib.
832        // trys to decrypt with crib.
833        private void auswerten(int keylength, int end, ArrayList all, byte[,] cribMatrix, byte[,] cipherMatrix)
834        {
835            Console.WriteLine("possible keylength: " + keylength);
836            // weiter analysieren (möglichen text finden)
837
838            //foreach (MiniCribPos abc in all)
839            //{
840            //    Console.WriteLine(abc.cribColumn + "(" + abc.xPos + "/" + abc.yPos + ")");
841            //}
842
843            Hashtable table = new Hashtable();
844
845            foreach (MiniCribPos abc in all)
846            {
847                if (table.ContainsKey(abc.xPos))
848                {
849                    int value = (int)table[abc.xPos];
850                    table.Remove(abc.xPos);
851                    table.Add(abc.xPos, value + 1);
852                }
853                else
854                {
855                    table.Add(abc.xPos, 1);
856                }
857            }
858
859            //höchste anzahl suchen
860            int highest = 0;
861            int amount = 0;
862
863            IDictionaryEnumerator _enumerator = table.GetEnumerator();
864            while (_enumerator.MoveNext())
865            {
866                if (((int)_enumerator.Value) > amount)
867                {
868                    amount = (int)_enumerator.Value;
869                    highest = (int)_enumerator.Key;
870                }
871            }
872            Console.WriteLine("highest pos: " + highest + " (" + amount + "x)");
873
874            // ordnen versuchen
875            Console.WriteLine("TOP:");
876            for (int a = 0; a < keylength; a++)
877            {
878                foreach (MiniCribPos m in all)
879                {
880                    if (m.xPos == highest && m.cribColumn == a)
881                    {
882                        Console.WriteLine(a + ": Zeile:" + m.yPos + " (enc)");
883                    }
884                }
885            }
886
887            Console.WriteLine("");
888            Console.WriteLine("+1");
889            for (int a = 0; a < keylength; a++)
890            {
891                foreach (MiniCribPos m in all)
892                {
893                    if (m.xPos == highest + 1 && m.cribColumn == a)
894                    {
895                        Console.WriteLine(a + "* Zeile :" + m.yPos + " (enc)");
896                    }
897                }
898            }
899
900            Console.WriteLine("");
901            Console.WriteLine("-1");
902            for (int a = 0; a < keylength; a++)
903            {
904                foreach (MiniCribPos m in all)
905                {
906                    if (m.xPos == highest - 1 && m.cribColumn == a)
907                    {
908                        Console.WriteLine(a + "* -Zeile : " + m.yPos + " (enc)");
909                    }
910                }
911            }
912            Console.WriteLine("-----------");
913
914            // Wenn MiniCribs mit nur einem Buchstaben vorhanden sind:
915            if (end < keylength)
916            {
917                int searchCol = highest;
918                Boolean searchColChanged = false;
919                for (int a = end; a < keylength; a++)
920                {
921                    byte mybte = cribMatrix[a, 0];
922                    Boolean found1 = false;
923                    for (int b = 0; b < keylength; b++)
924                    {
925                        if ((cipherMatrix[searchCol, b] == mybte))
926                        {
927                            found1 = true;
928                            Console.WriteLine(a + ": Zeile " + b + "   col:" + searchCol);
929                        }
930                    }
931                    if (!found1)
932                    {
933                        if (!searchColChanged)
934                        {
935                            searchColChanged = true;
936                            a--;
937                            searchCol++;
938                        }
939                        else
940                        {
941                            break;
942                        }
943
944                    }
945                }
946            }
947        }
948
949        private void auswertenNeu(int keylength, int end, ArrayList all, byte[,] cribMatrix, byte[,] cipherMatrix)
950        {
951            Console.WriteLine("possible keylength: " + keylength);
952            // weiter analysieren (möglichen text finden)
953
954            foreach (MiniCribPos abc in all)
955            {
956                Console.WriteLine(abc.cribColumn + "(" + abc.xPos + "/" + abc.yPos + ")");
957            }
958
959            Hashtable table = new Hashtable();
960
961            foreach (MiniCribPos abc in all)
962            {
963                if (table.ContainsKey(abc.xPos))
964                {
965                    int value = (int)table[abc.xPos];
966                    table.Remove(abc.xPos);
967                    table.Add(abc.xPos, value + 1);
968                }
969                else
970                {
971                    table.Add(abc.xPos, 1);
972                }
973            }
974
975            //höchste anzahl suchen
976            int highest = 0;
977            int amount = 0;
978
979            IDictionaryEnumerator _enumerator = table.GetEnumerator();
980            while (_enumerator.MoveNext())
981            {
982                if (((int)_enumerator.Value) > amount)
983                {
984                    amount = (int)_enumerator.Value;
985                    highest = (int)_enumerator.Key;
986                }
987            }
988            Console.WriteLine("highest: " + highest + ": " + amount + "x");
989
990            int pos = 0;
991            amount = 0;
992
993            Dingens ding = new Dingens(keylength);
994            foreach (MiniCribPos m in all)
995            {
996                if ((m.xPos == highest - 1 || m.xPos == highest || m.xPos == highest + 1))
997                {
998                    ding.add(m.cribColumn, m.yPos, m.xPos - highest);
999                }
1000            }
1001
1002            // Wenn MiniCribs mit nur einem Buchstaben vorhanden sind:
1003            if (end < keylength)
1004            {
1005                Boolean searchColChanged = false;
1006                for (int a = end; a < keylength; a++)
1007                {
1008                    byte mybte = cribMatrix[a, 0];
1009
1010                    for (int b = 0; b < keylength; b++)
1011                    {
1012                        if ((cipherMatrix[highest - 1, b] == mybte))
1013                        {
1014                            ding.add(a, b, -1);
1015                        }
1016                        if ((cipherMatrix[highest, b] == mybte))
1017                        {
1018                            ding.add(a, b, 0);
1019                        }
1020                        if ((cipherMatrix[highest + 1, b] == mybte))
1021                        {
1022                            ding.add(a, b, +1);
1023                        }
1024                    }
1025                }
1026            }
1027
1028            for (int i = 0; i < keylength; i++)
1029            {
1030                if (ding.getSize(i) == 1)
1031                {
1032                    int val = ding.getColumn(i)[0].getValue();
1033                    int shift = ding.getColumn(i)[0].getShift();
1034
1035                    for (int j = 0; j < keylength; j++)
1036                    {
1037                        if (i != j && ding.getSize(j) > 0)
1038                        {
1039                            Dingens2[] column = ding.getColumn(j);
1040                            for (int a = 0; a < column.Length; a++)
1041                            {
1042                                if (column[a].getValue() == val)
1043                                {
1044                                    ding.delete(j, val);
1045                                    Console.WriteLine("Delete: " + j + "/" + val + "(" + shift + ")");
1046                                }
1047                            }
1048                        }
1049                    }
1050                }
1051            }
1052
1053            for (int i = 0; i < keylength; i++)
1054            {
1055                Console.WriteLine(i + " mögliche Zeilen der encMatrix: " + ding.getString(i));
1056            }
1057
1058            tablelist.Add(ding);
1059            ars.Set();
1060           
1061        }
1062       
1063       
1064
1065        #endregion
1066
1067        #region
1068
1069        public ArrayList getKeyLength(byte[] crib, byte[] cipher)
1070        {
1071
1072            ArrayList keylengths = new ArrayList();
1073
1074            for (int i = 1; i < crib.Length; i++)
1075            {
1076                byte[,] cipherM = cipherToMatrix(i, cipher);
1077                byte[,] cribM = cribToMatrix(i, crib);
1078                int[] analysed = analyse(i, cipherM, cribM);
1079
1080                for (int j = 0; j < analysed.Length; j++)
1081                {
1082
1083                    if (analysed[j] != 0)
1084                    {
1085                        if (j == analysed.Length - 1)
1086                        {
1087                            keylengths.Add(i);
1088                        }
1089                    }
1090                    else break;
1091                }
1092
1093            }
1094            return keylengths;
1095
1096        }
1097
1098        byte[,] cribToMatrix(int i, byte[] tmp)
1099        {
1100            int x = tmp.Length / i;
1101            if (tmp.Length % i != 0)
1102            {
1103                x++;
1104            }
1105            byte[,] arr = new byte[i, x];
1106            int count = 0;
1107
1108            for (int a = 0; a < x; a++)
1109            {
1110                for (int b = 0; b < i; b++)
1111                {
1112                    if (count < tmp.Length)
1113                        arr[b, a] = tmp[count++];
1114                }
1115            }
1116            return arr;
1117        }
1118
1119        byte[,] cipherToMatrix(int i, byte[] tmp)
1120        {
1121            int length = tmp.Length / i;
1122            int off = 0;
1123            if (tmp.Length % i != 0)
1124            {
1125                length++;
1126                off = (i * length) - tmp.Length;
1127            }
1128            byte[,] cipherMatrix = new byte[length, i];
1129            int pos = 0;
1130
1131            for (int a = 0; a < i; a++)
1132            {
1133                for (int b = 0; b < length; b++)
1134                {
1135                    if (b == length - 1)
1136                    {
1137                        if (a < off)
1138                        {
1139                            break;
1140                        }
1141                    }
1142                    cipherMatrix[b, a] = tmp[pos];
1143                    pos++;
1144                }
1145            }
1146            return cipherMatrix;
1147        }
1148
1149        int[] analyse(int i, byte[,] cipherMatrix, byte[,] cribMatrix)
1150        {
1151            int cipherMatrixLength = cipherMatrix.Length / i;
1152            int cribMatrixHeight = cribMatrix.Length / i;
1153            int[] poscount = new int[i];
1154            ArrayList[] def = new ArrayList[i];
1155            for (int a = 0; a < i; a++)
1156            {
1157                def[a] = new ArrayList();
1158            }
1159
1160            byte newchar = new byte();
1161            byte emptychar = new byte();
1162            int count = 0;
1163            for (int a = 0; a < i; a++)
1164            {
1165                if (!cribMatrix[a, cribMatrixHeight - 1].Equals(emptychar))
1166                {
1167                    count++;
1168                }
1169                else
1170                {
1171                    poscount[a] = -1;
1172                }
1173            }
1174
1175            for (int x = 0; x < count; x++)
1176            {
1177                for (int a = 0; a < i; a++)
1178                {
1179                    for (int b = 0; b < cipherMatrixLength; b++)
1180                    {
1181                        if (cribMatrix[x, 0].Equals(cipherMatrix[b, a]))
1182                        {
1183                            int tmpA = a;
1184                            int tmpB = b;
1185
1186                            for (int y = 1; y < cribMatrixHeight; y++)
1187                            {
1188                                tmpB++;
1189                                if (tmpB == cipherMatrixLength - 1)
1190                                {
1191                                    if (cipherMatrix[tmpB, tmpA].Equals(newchar))
1192                                    {
1193                                        tmpB = 0;
1194                                        tmpA++;
1195                                    }
1196                                }
1197
1198                                if ((tmpB) < cipherMatrixLength)
1199                                {
1200                                    if (cribMatrix[x, y].Equals(cipherMatrix[tmpB, tmpA]))
1201                                    {
1202                                        if (y.Equals(cribMatrixHeight - 1))
1203                                        {
1204                                            poscount[x]++;
1205                                            def[x].Add(b);
1206
1207                                        }
1208                                    }
1209                                    else
1210                                    {
1211                                        break;
1212                                    }
1213                                }
1214                            }
1215                        }
1216                    }
1217                }
1218            }
1219            return poscount;
1220        }
1221
1222        #endregion
1223
1224        private void showProgress(DateTime startTime, long size, long sum)
1225        {
1226            LinkedListNode<ValueKey> linkedListNode;
1227            if (QuickWatchPresentation.IsVisible && !stop)
1228            {
1229                DateTime currentTime = DateTime.Now;
1230                TimeSpan span = currentTime.Subtract(startTime);
1231                int seconds = span.Seconds;
1232                int minutes = span.Minutes;
1233                int hours = span.Hours;
1234                int days = span.Days;
1235
1236                long allseconds = seconds + 60 * minutes + 60 * 60 * hours + 24 * 60 * 60 * days;
1237                if (allseconds == 0) allseconds = 1;
1238                long keysPerSec = sum / allseconds;
1239
1240                long keystodo = (size - sum);
1241               
1242                long secstodo = keystodo / keysPerSec;
1243
1244                //dummy Time
1245                DateTime endTime = new DateTime(1970, 1, 1);
1246                try
1247                {
1248                    endTime = DateTime.Now.AddSeconds(secstodo);
1249                }
1250                catch
1251                {
1252
1253                }
1254
1255
1256                ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
1257                {
1258
1259                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).keysPerSecond.Text = "" + keysPerSec;
1260
1261                    if (endTime != (new DateTime(1970, 1, 1)))
1262                    {
1263                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Text = "" + endTime.Subtract(DateTime.Now);
1264
1265                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Text = "" + endTime;
1266                    }
1267                    else
1268                    {
1269                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Text = "incalculable";
1270
1271                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Text = "in a galaxy far, far away...";
1272                    }
1273                    if (list1 != null)
1274                    {
1275                        linkedListNode = list1.First;
1276                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Clear();
1277                        int i = 0;
1278                        while (linkedListNode != null)
1279                        {
1280                            i++;
1281                            ResultEntry entry = new ResultEntry();
1282                            entry.Ranking = i.ToString();
1283
1284
1285                            String dec = System.Text.Encoding.ASCII.GetString(linkedListNode.Value.decryption);
1286                            if (dec.Length > 2500) // Short strings need not to be cut off
1287                            {
1288                                dec = dec.Substring(0, 2500);
1289                            }
1290                            entry.Text = dec;
1291                            entry.Key = linkedListNode.Value.key;
1292                            entry.Value = Math.Round(linkedListNode.Value.value, 2) + "";
1293
1294
1295                            ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Add(entry);
1296
1297                            linkedListNode = linkedListNode.Next;
1298                        }
1299
1300                    }
1301                }
1302
1303
1304                , null);
1305
1306            }
1307        }
1308
1309        private void geneticAnalysis(IControlEncryption sender)
1310        {
1311            stop = false;
1312
1313            valuequeue = Queue.Synchronized(new Queue());
1314           
1315            int size = settings.Iterations;
1316            int keylength = settings.KeySize;
1317            int repeatings = settings.Repeatings;
1318
1319            if (size < 2 || keylength < 2 || repeatings <1)
1320            {
1321                GuiLogMessage("Check keylength and iterations", NotificationLevel.Error);
1322                return;
1323            }
1324
1325            if (sender == null || costMaster == null || input == null)
1326            {
1327                if (sender == null)
1328                {
1329                    GuiLogMessage("sender == null", NotificationLevel.Error);
1330                }
1331                if (costMaster == null)
1332                {
1333                    GuiLogMessage("costMaster == null", NotificationLevel.Error);
1334                }
1335                if (input == null)
1336                {
1337                    GuiLogMessage("input == null", NotificationLevel.Error);
1338                }
1339                return;
1340            }
1341            DateTime startTime = DateTime.Now;
1342            DateTime lastUpdate = DateTime.Now;
1343
1344            ArrayList bestOf = null;
1345
1346            for (int it = 0; it < repeatings; it++)
1347            {
1348
1349                ArrayList valList = new ArrayList();
1350               
1351                for (int i = 0; i < 12; i++)
1352                {
1353                    byte[] rndkey = randomArray(keylength);
1354                    byte[] dec = sender.Decrypt(input, rndkey, null);
1355                    double val = costMaster.calculateCost(dec);
1356
1357                    String keyStr = "";
1358                    foreach (byte tmp in rndkey)
1359                    {
1360                        keyStr += tmp + ", ";
1361                    }
1362
1363
1364                    ValueKey v = new ValueKey();
1365                    v.decryption = dec;
1366                    v.key = keyStr;
1367                    v.keyArray = rndkey;
1368                    v.value = val;
1369                    valList.Add(v);
1370                }
1371
1372                valuequeue = Queue.Synchronized(new Queue());
1373
1374
1375                int iteration = 0;
1376                while (iteration < size && !stop)
1377                {
1378                    //Dummy ValueKey erstellen:
1379                    ValueKey highest = new ValueKey();
1380
1381                    // Schlechtesten 6 Keys löschen
1382                    if (costMaster.getRelationOperator() == RelationOperator.LessThen)
1383                    {
1384                        for (int a = 0; a < 6; a++)
1385                        {
1386                            highest.value = int.MinValue;
1387                            int pos = -1;
1388                            for (int b = 0; b < valList.Count; b++)
1389                            {
1390                                ValueKey v = (ValueKey)valList[b];
1391                                if (v.value > highest.value)
1392                                {
1393                                    highest = v;
1394                                    pos = b;
1395                                }
1396                            }
1397                            if (pos != -1)
1398                            {
1399                                valList.RemoveAt(pos);
1400                            }
1401                        }
1402                    }
1403                    //costmMaster Relation Operator == Larger Than
1404                    else
1405                    {
1406                        for (int a = 0; a < 6; a++)
1407                        {
1408                            highest.value = int.MaxValue;
1409                            int pos = -1;
1410                            for (int b = 0; b < valList.Count; b++)
1411                            {
1412                                ValueKey v = (ValueKey)valList[b];
1413                                if (v.value < highest.value)
1414                                {
1415                                    highest = v;
1416                                    pos = b;
1417                                }
1418                            }
1419                            if (pos != -1)
1420                            {
1421                                valList.RemoveAt(pos);
1422                            }
1423                        }
1424                    }
1425
1426                    //valListe sortieren
1427                    ArrayList tmpList = new ArrayList(6);
1428
1429                    double best = Double.MinValue;
1430                    int bestpos = -1;
1431                    for (int a = 0; a < 6; a++)
1432                    {
1433                        best = Double.MinValue;
1434                        bestpos = -1;
1435
1436                        for (int b = 0; b < valList.Count; b++)
1437                        {
1438                            ValueKey v = (ValueKey)valList[b];
1439
1440                            if (best == Double.MinValue)
1441                            {
1442                                best = v.value;
1443                                bestpos = b;
1444                            }
1445
1446                            if (costMaster.getRelationOperator() == RelationOperator.LessThen)
1447                            {
1448                                if (v.value < best)
1449                                {
1450                                    best = v.value;
1451                                    bestpos = b;
1452                                }
1453                            }
1454                            else
1455                            {
1456                                if (v.value > best)
1457                                {
1458                                    best = v.value;
1459                                    bestpos = b;
1460                                }
1461                            }
1462                        }
1463                        tmpList.Add(valList[bestpos]);
1464                        valList.RemoveAt(bestpos);
1465
1466                    }
1467
1468                    valList = tmpList;
1469
1470
1471                    // Kinder der besten Keys erstellen
1472                    int rndInt = 0;
1473
1474                    int listSize = valList.Count;
1475                    for (int a = 0; a < 6; a++)
1476                    {
1477                        if (a % 2 == 0)
1478                        {
1479                            rndInt = (rd.Next(0, int.MaxValue)) % (keylength);
1480                            while (rndInt == 0)
1481                            {
1482                                rndInt = (rd.Next(0, int.MaxValue)) % (keylength);
1483                            }
1484                        }
1485
1486                        ValueKey parent1 = (ValueKey)valList[a];
1487                        byte[] child = new byte[parent1.keyArray.Length];
1488                        for (int b = 0; b < rndInt; b++)
1489                        {
1490                            child[b] = parent1.keyArray[b];
1491                        }
1492
1493                        int pos = rndInt;
1494                        if (a % 2 == 0)
1495                        {
1496                            ValueKey parent2 = (ValueKey)valList[a + 1];
1497                            for (int b = 0; b < parent2.keyArray.Length; b++)
1498                            {
1499                                for (int c = rndInt; c < parent1.keyArray.Length; c++)
1500                                {
1501                                    if (parent1.keyArray[c] == parent2.keyArray[b])
1502                                    {
1503                                        child[pos] = parent1.keyArray[c];
1504                                        pos++;
1505                                        break;
1506                                    }
1507                                }
1508                            }
1509                        }
1510                        else
1511                        {
1512                            ValueKey parent2 = (ValueKey)valList[a - 1];
1513                            for (int b = 0; b < parent2.keyArray.Length; b++)
1514                            {
1515                                for (int c = rndInt; c < parent1.keyArray.Length; c++)
1516                                {
1517                                    if (parent1.keyArray[c] == parent2.keyArray[b])
1518                                    {
1519                                        child[pos] = parent1.keyArray[c];
1520                                        pos++;
1521                                        break;
1522                                    }
1523                                }
1524                            }
1525                        }
1526                        int apos = (rd.Next(0, int.MaxValue)) % keylength;
1527                        int bpos = (rd.Next(0, int.MaxValue)) % keylength;
1528                        while (apos == bpos)
1529                        {
1530                            apos = (rd.Next(0, int.MaxValue)) % keylength;
1531                            bpos = (rd.Next(0, int.MaxValue)) % keylength;
1532                        }
1533                        byte tmp = child[apos];
1534                        child[apos] = child[bpos];
1535                        child[bpos] = tmp;
1536
1537                        Boolean eq = false;
1538                        foreach (ValueKey v in valList)
1539                        {
1540
1541                            if (arrayEquals(v.keyArray, child))
1542                            {
1543                                //GuiLogMessage("ZWEI GLEICHE", NotificationLevel.Debug);
1544                                ValueKey tmpValue = new ValueKey();
1545                                tmpValue.keyArray = randomArray(keylength);
1546                                byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
1547                                double val = costMaster.calculateCost(dec);
1548
1549                                String keyStr = "";
1550                                foreach (byte bb in child)
1551                                {
1552                                    keyStr += bb + ", ";
1553                                }
1554
1555                                tmpValue.decryption = dec;
1556                                tmpValue.key = keyStr;
1557                                tmpValue.value = val;
1558                                valList.Add(tmpValue);
1559                                eq = true;
1560                                break;
1561                            }
1562                        }
1563                        if (!eq && bestOf != null)
1564                        {
1565                            foreach (ValueKey v in bestOf)
1566                            {
1567
1568                                if (arrayEquals(v.keyArray, child))
1569                                {
1570                                    //GuiLogMessage("ZWEI GLEICHE", NotificationLevel.Debug);
1571                                    ValueKey tmpValue = new ValueKey();
1572                                    tmpValue.keyArray = randomArray(keylength);
1573                                    byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
1574                                    double val = costMaster.calculateCost(dec);
1575
1576                                    String keyStr = "";
1577                                    foreach (byte bb in child)
1578                                    {
1579                                        keyStr += bb + ", ";
1580                                    }
1581
1582                                    tmpValue.decryption = dec;
1583                                    tmpValue.key = keyStr;
1584                                    tmpValue.value = val;
1585                                    valList.Add(tmpValue);
1586                                    eq = true;
1587                                    break;
1588                                }
1589                            }
1590                        }
1591                        if (!eq)
1592                        {
1593                            ValueKey tmpValue = new ValueKey();
1594                            byte[] dec = sender.Decrypt(input, child, null);
1595                            double val = costMaster.calculateCost(dec);
1596
1597                            String keyStr = "";
1598                            foreach (byte bb in child)
1599                            {
1600                                keyStr += bb + ", ";
1601                            }
1602
1603                            tmpValue.keyArray = child;
1604                            tmpValue.decryption = dec;
1605                            tmpValue.key = keyStr;
1606                            tmpValue.value = val;
1607                            valList.Add(tmpValue);
1608                        }
1609                    }
1610
1611                    if (DateTime.Now >= lastUpdate.AddMilliseconds(1000))
1612                    {
1613                        best = Double.MinValue;
1614
1615                        if (costMaster.getRelationOperator() == RelationOperator.LessThen)
1616                        {
1617                            best = Double.MaxValue;
1618                        }
1619
1620                        list1 = getDummyLinkedList(best);
1621
1622                        if (bestOf != null)
1623                        {
1624                            foreach (ValueKey v in bestOf)
1625                            {
1626                                valuequeue.Enqueue(v);
1627                            }
1628                        }
1629
1630                        foreach (ValueKey v in valList)
1631                        {
1632                            valuequeue.Enqueue(v);
1633                        }
1634                        updateToplist(list1);
1635                        showProgress(startTime, size * repeatings, it * size + iteration);
1636                        ProgressChanged(it*size+ iteration, size*repeatings);
1637                        lastUpdate = DateTime.Now;
1638                    }
1639                    iteration++;
1640                }
1641                foreach (ValueKey v in valList)
1642                {
1643                    if (bestOf == null)
1644                        bestOf = new ArrayList();
1645                    bestOf.Add(v);
1646                }
1647            }
1648        }
1649
1650        private byte[] randomArray(int length)
1651        {
1652            int[] src = new int[length];
1653            for (int i = 0; i < length; i++)
1654            {
1655                src[i] = i + 1;
1656            }
1657            if (src == null)
1658            {
1659                return null;
1660            }
1661
1662            int[] tmp = new int[src.Length];
1663
1664            int num = src.Length;
1665            int index;
1666
1667            if (rd == null) rd = new Random(System.DateTime.Now.Millisecond);
1668
1669            for (int i = 0; i < src.Length; i++)
1670            {
1671                index = (rd.Next(0, int.MaxValue)) % num;
1672                tmp[i] = src[index];
1673                src[index] = src[num - 1];
1674                num--;
1675            }
1676
1677            byte[] output = new byte[length];
1678            for (int i = 0; i < output.Length; i++)
1679            {
1680                output[i] = Convert.ToByte(tmp[i]);
1681            }
1682            return output;
1683        }
1684
1685        private Boolean arrayEquals(byte[] a, byte[] b)
1686        {
1687            if (a.Length != b.Length)
1688                return false;
1689            for (int i = 0; i < a.Length; i++)
1690            {
1691                if (a[i] != b[i]) return false;
1692            }
1693            return true;
1694        }
1695
1696
1697    }
1698
1699    public struct ValueKey
1700    {
1701        public byte[] keyArray;
1702        public double value;
1703        public String key;
1704        public byte[] decryption;
1705    };
1706    public class ResultEntry
1707    {
1708        public string Ranking { get; set; }
1709        public string Value { get; set; }
1710        public string Key { get; set; }
1711        public string Text { get; set; }
1712
1713    }
1714    class MiniCribPos
1715    {
1716        public int cribColumn { get; set; }
1717        public int xPos { get; set; }
1718        public int yPos { get; set; }
1719
1720        public MiniCribPos(int cribColumn, int xPos, int yPos)
1721        {
1722            this.cribColumn = cribColumn;
1723            this.xPos = xPos;
1724            this.yPos = yPos;
1725        }
1726    }
1727
1728    class Dingens
1729    {
1730        Dingens2[,] dingens;
1731        int length = 0;
1732
1733        public Dingens(int length)
1734        {
1735            this.length = length;
1736            dingens = new Dingens2[length, length];
1737        }
1738
1739        public void add(int column, int value, int shift)
1740        {
1741            if (column < length)
1742            {
1743                for (int i = 0; i < length; i++)
1744                {
1745                    if (dingens[column, i] == null)
1746                    {
1747                        dingens[column, i] = new Dingens2(value, shift);
1748                        break;
1749                    }
1750                }
1751            }
1752        }
1753        public int getCount()
1754        {
1755            return length;
1756        }
1757        public int getSize(int column)
1758        {
1759            int count = 0;
1760            if (column < length)
1761            {
1762                for (int i = 0; i < length; i++)
1763                {
1764                    if (dingens[column, i] != null)
1765                    {
1766                        count++;
1767                    }
1768                }
1769            }
1770            return count;
1771        }
1772
1773        public void delete(int column, int value)
1774        {
1775            if (column < length)
1776            {
1777                for (int i = 0; i < length; i++)
1778                {
1779                    if (dingens[column, i] != null)
1780                    {
1781                        if (dingens[column, i].getValue() == value)
1782                        {
1783
1784                            dingens[column, i] = null;
1785                        }
1786                    }
1787                }
1788            }
1789        }
1790
1791        public String getString(int column)
1792        {
1793            String output = "";
1794            if (column < length)
1795            {
1796                for (int i = 0; i < length; i++)
1797                {
1798                    if (dingens[column, i] != null)
1799                    {
1800                        output = output + dingens[column, i].getValue() + "(s=" + dingens[column, i].getShift() + "),";
1801                    }
1802                }
1803            }
1804            return output;
1805        }
1806
1807        public Dingens2[] getColumn(int column)
1808        {
1809            int size = 0;
1810            for (int i = 0; i < length; i++)
1811            {
1812                if (dingens[column, i] != null) size++;
1813            }
1814
1815            Dingens2[] columnArray = new Dingens2[size];
1816            int count = 0;
1817            for (int i = 0; i < length; i++)
1818            {
1819                if (dingens[column, i] != null) columnArray[count++] = dingens[column, i];
1820            }
1821            return columnArray;
1822        }
1823        public int[,] toint()
1824        {
1825            int[,] res = new int[length, length];
1826            for (int i = 0; i < length; i++)
1827            {
1828                for (int ix = 0; ix < length; ix++)
1829                {
1830                    res[i, ix] = 0;
1831                }
1832            }
1833
1834            for (int i = 0; i < dingens.GetLength(0); i++)
1835            {
1836                for (int ix = 0; ix < dingens.GetLength(1); ix++)
1837                {
1838                    if (dingens[i, ix] != null)
1839                    {
1840                        res[i, ix] = dingens[i, ix].getValue()+1;
1841                    }
1842                }
1843            }
1844            return res;
1845        }
1846    }
1847
1848    class Dingens2
1849    {
1850        int value;
1851        int shift;
1852
1853        public Dingens2(int value, int shift)
1854        {
1855            this.value = value;
1856            this.shift = shift;
1857        }
1858
1859        public int getValue()
1860        {
1861            return value;
1862        }
1863
1864        public int getShift()
1865        {
1866            return shift;
1867        }
1868    }
1869
1870}
Note: See TracBrowser for help on using the repository browser.