Changeset 1985


Ignore:
Timestamp:
Oct 18, 2010, 5:18:47 PM (11 years ago)
Author:
kohnen
Message:
  • Added crib analysis to TranspositionAnalyser.
  • deleted old (not working) crib analysis from TranspositionAnalyser

Just row-column-column transposition analysis possible at the moment.

Location:
trunk/CrypPlugins/TranspositionAnalyser
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/TranspositionAnalyser/TranspositionAnalyser.cs

    r1789 r1985  
    6969
    7070        #endregion
     71
    7172        /// <summary>
    7273        /// Constructor
     
    102103        }
    103104
    104      
     105
    105106
    106107        private IControlCost costMaster;
     
    168169        {
    169170
    170            
     171
    171172            if (this.input != null)
    172173            {
     
    233234                {
    234235                    case 0: Output = costfunction_bruteforce(sender); GuiLogMessage("Starting Brute-Force Analysis", NotificationLevel.Info); break;
     236
    235237                    case 1: GuiLogMessage("Starting Analysis with crib", NotificationLevel.Info); cribAnalysis(sender, this.crib, this.input); break;
     238
    236239                    case 2: GuiLogMessage("Starting genetic analysis", NotificationLevel.Info); geneticAnalysis(sender); break;
    237240                }
     
    244247
    245248        }
     249
     250        private void updateToplist(LinkedList<ValueKey> costList)
     251        {
     252            LinkedListNode<ValueKey> node;
     253
     254            while (valuequeue.Count != 0)
     255            {
     256                ValueKey vk = (ValueKey)valuequeue.Dequeue();
     257                if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
     258                {
     259                    if (vk.value > costList.Last().value)
     260                    {
     261                        node = costList.First;
     262                        int i = 0;
     263                        while (node != null)
     264                        {
     265                            if (vk.value > node.Value.value)
     266                            {
     267                                costList.AddBefore(node, vk);
     268                                costList.RemoveLast();
     269                                if (i == 0)
     270                                {
     271                                    Output = vk.decryption;
     272                                }
     273                                // value_threshold = costList.Last.Value.value;
     274                                break;
     275                            }
     276                            node = node.Next;
     277                            i++;
     278                        }//end while
     279                    }//end if
     280                }
     281                else
     282                {
     283                    if (vk.value < costList.Last().value)
     284                    {
     285                        node = costList.First;
     286                        int i = 0;
     287                        while (node != null)
     288                        {
     289                            if (vk.value < node.Value.value)
     290                            {
     291                                costList.AddBefore(node, vk);
     292                                costList.RemoveLast();
     293                                if (i == 0)
     294                                {
     295                                    Output = vk.decryption;
     296                                }
     297
     298                                // value_threshold = costList.Last.Value.value;
     299                                break;
     300                            }
     301                            node = node.Next;
     302                            i++;
     303                        }//end while
     304                    }//end if
     305                }
     306            }
     307        }
     308
     309        public void ProgressChanged(double value, double max)
     310        {
     311            if (OnPluginProgressChanged != null)
     312            {
     313                OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
     314
     315            }
     316        }
     317
     318        private void showProgress(DateTime startTime, long size, long sum)
     319        {
     320            LinkedListNode<ValueKey> linkedListNode;
     321            if (QuickWatchPresentation.IsVisible && !stop)
     322            {
     323                DateTime currentTime = DateTime.Now;
     324
     325                TimeSpan elapsedtime = DateTime.Now.Subtract(startTime); ;
     326                TimeSpan elapsedspan = new TimeSpan(elapsedtime.Days, elapsedtime.Hours, elapsedtime.Minutes, elapsedtime.Seconds, 0);
     327
     328
     329
     330                TimeSpan span = currentTime.Subtract(startTime);
     331                int seconds = span.Seconds;
     332                int minutes = span.Minutes;
     333                int hours = span.Hours;
     334                int days = span.Days;
     335
     336                long allseconds = seconds + 60 * minutes + 60 * 60 * hours + 24 * 60 * 60 * days;
     337                if (allseconds == 0) allseconds = 1;
     338                long keysPerSec = sum / allseconds;
     339
     340                long keystodo = (size - sum);
     341
     342                long secstodo = keystodo / keysPerSec;
     343
     344                //dummy Time
     345                DateTime endTime = new DateTime(1970, 1, 1);
     346                try
     347                {
     348                    endTime = DateTime.Now.AddSeconds(secstodo);
     349                }
     350                catch
     351                {
     352
     353                }
     354
     355
     356                ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     357                {
     358
     359                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).startTime.Content = "" + startTime;
     360                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).keysPerSecond.Content = "" + keysPerSec;
     361
     362
     363                    if (endTime != (new DateTime(1970, 1, 1)))
     364                    {
     365                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Content = "" + endTime.Subtract(DateTime.Now);
     366                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).elapsedTime.Content = "" + elapsedspan;
     367                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Content = "" + endTime;
     368                    }
     369                    else
     370                    {
     371                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Content = "incalculable";
     372
     373                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Content = "in a galaxy far, far away...";
     374                    }
     375                    if (list1 != null)
     376                    {
     377                        linkedListNode = list1.First;
     378                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Clear();
     379                        int i = 0;
     380                        while (linkedListNode != null)
     381                        {
     382                            i++;
     383                            ResultEntry entry = new ResultEntry();
     384                            entry.Ranking = i.ToString();
     385
     386
     387                            String dec = System.Text.Encoding.ASCII.GetString(linkedListNode.Value.decryption);
     388                            if (dec.Length > 2500) // Short strings need not to be cut off
     389                            {
     390                                dec = dec.Substring(0, 2500);
     391                            }
     392                            entry.Text = dec;
     393                            entry.Key = linkedListNode.Value.key;
     394                            entry.Value = Math.Round(linkedListNode.Value.value, 2) + "";
     395
     396
     397                            ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).entries.Add(entry);
     398
     399                            linkedListNode = linkedListNode.Next;
     400                        }
     401
     402                    }
     403                }
     404                , null);
     405
     406            }
     407        }
     408
     409        #endregion
     410
     411        #region INotifyPropertyChanged Member
     412
     413        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
     414
     415        #endregion
     416
     417        #region bruteforce
    246418
    247419        private int[] getBruteforceSettings()
     
    307479                ArrayList list = null;
    308480
    309                
     481
    310482                //Just for fractional-calculation:
    311483                PermutationGenerator per = new PermutationGenerator(2);
     
    381553                                            foreach (int xyz in key)
    382554                                            {
    383                                                 keyStr += xyz +", ";
     555                                                keyStr += xyz + ", ";
    384556                                            }
    385557                                            valkey.decryption = dec;
     
    445617        }
    446618
     619        #endregion
     620
    447621        private LinkedList<ValueKey> getDummyLinkedList(double best)
    448622        {
     
    460634        }
    461635
    462         private void updateToplist(LinkedList<ValueKey> costList)
    463         {
    464             LinkedListNode<ValueKey> node;
    465            
    466             while (valuequeue.Count != 0)
    467             {
    468                 ValueKey vk = (ValueKey)valuequeue.Dequeue();
    469                 if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
    470                 {
    471                     if (vk.value > costList.Last().value)
    472                     {
    473                         node = costList.First;
    474                         int i = 0;
    475                         while (node != null)
    476                         {
    477                             if (vk.value > node.Value.value)
    478                             {
    479                                 costList.AddBefore(node, vk);
    480                                 costList.RemoveLast();
    481                                 if (i == 0)
     636        #region cribAnalysis
     637
     638        private ArrayList bestlist;
     639        private ArrayList valList;
     640        private long sumBinKeys;
     641        private int countBinKeys;
     642        private int binKeysPerSec;
     643        private int[] keysLastTenSecs;
     644        private int poskeysLastTenSecs;
     645        private int searchPosition;
     646        private DateTime starttime;
     647        private DateTime lastUpdate;
     648
     649        private void cribAnalysis(IControlEncryption sender, byte[] crib, byte[] cipher)
     650        {
     651            valList = new ArrayList();
     652            bestlist = new ArrayList();
     653            valuequeue = Queue.Synchronized(new Queue());
     654            starttime = DateTime.Now;
     655            lastUpdate = DateTime.Now;
     656
     657            int maxKeylength = settings.CribSearchKeylength;
     658
     659            if (maxKeylength <= 1)
     660            {
     661                GuiLogMessage("Keylength must be greater than 1", NotificationLevel.Error);
     662                return;
     663            }
     664
     665            if (maxKeylength > crib.Length)
     666            {
     667                GuiLogMessage("Crib must be longer than maximum keylength", NotificationLevel.Error);
     668                return;
     669            }
     670
     671            if (crib == null)
     672            {
     673                GuiLogMessage("crib == null", NotificationLevel.Error);
     674                return;
     675            }
     676
     677            if (cipher== null)
     678            {
     679                GuiLogMessage("cipher == null", NotificationLevel.Error);
     680                return;
     681            }
     682
     683            if (crib.Length < 2)
     684            {
     685                GuiLogMessage("Crib is too short.", NotificationLevel.Error);
     686                return;
     687            }
     688
     689            for (int keylength = 2; keylength <= maxKeylength; keylength++)
     690            {
     691                sumBinKeys += binomial_iter(keylength, cipher.Length % keylength);
     692            }
     693
     694            keysLastTenSecs = new int[10];
     695            poskeysLastTenSecs = 0;
     696
     697            for (int keylength = 2; keylength <= maxKeylength; keylength++)
     698            {
     699                int[] binaryKey = getDefaultBinaryKey(cipher, keylength);
     700                int[] firstKey = (int[])binaryKey.Clone();
     701
     702                do
     703                {
     704                    countBinKeys++;
     705                    binKeysPerSec++;
     706                    byte[,] cipherMatrix = cipherToMatrix(cipher, binaryKey);
     707                    byte[,] cribMatrix = cribToMatrix(crib, keylength);
     708                    ArrayList possibleList = analysis(sender, cipher, cipherMatrix, cribMatrix, keylength);
     709
     710                    Boolean eq;
     711                    foreach (int[] k in possibleList)
     712                    {
     713                        eq = false;
     714                        foreach (int[] kbest in bestlist)
     715                        {
     716                            if (arrayEquals(k, kbest))
     717                                eq = true;
     718                        }
     719                        if (!eq)
     720                        {
     721                            addToBestList(sender, k);
     722                        }
     723                    }
     724
     725                    binaryKey = nextPossible(binaryKey, binaryKey.Sum());
     726
     727                    if (DateTime.Now >= lastUpdate.AddMilliseconds(1000))
     728                    {
     729                        keysLastTenSecs[(poskeysLastTenSecs++ % 10)] = binKeysPerSec;
     730
     731                        if (DateTime.Now < starttime.AddMilliseconds(12000))
     732                        {
     733                            showProgressCribAnalysis(starttime, sumBinKeys, countBinKeys, binKeysPerSec);
     734                        }
     735                        else
     736                        {
     737                            int keysPerSec = keysLastTenSecs.Sum() / 10;
     738                            showProgressCribAnalysis(starttime, sumBinKeys, countBinKeys, keysPerSec);
     739                        }
     740
     741                        showBestKeysCribSearch();
     742                        binKeysPerSec = 0;
     743                        lastUpdate = DateTime.Now;
     744                        showProgress(starttime, sumBinKeys, countBinKeys);
     745                        ProgressChanged(countBinKeys, sumBinKeys);
     746
     747                       
     748                    }
     749
     750                } while (!arrayEquals(firstKey, binaryKey));
     751            }
     752
     753            showBestKeysCribSearch();
     754            showProgress(starttime, 1, 1);
     755            ProgressChanged(1, 1);
     756        }
     757
     758        private void showBestKeysCribSearch()
     759        {
     760            valList = updateValueKeyArrayList(valList, 12);
     761
     762            Double best = Double.MinValue;
     763
     764            if (costMaster.getRelationOperator() == RelationOperator.LessThen)
     765            {
     766                best = Double.MaxValue;
     767            }
     768
     769            foreach (ValueKey v in valList)
     770            {
     771                valuequeue.Enqueue(v);
     772            }
     773
     774            list1 = getDummyLinkedList(best);
     775            updateToplist(list1);
     776        }
     777
     778        private void addToBestList(IControlEncryption sender, int[] k)
     779        {
     780            int[] first = (int[])k.Clone();
     781
     782            do
     783            {
     784                bestlist.Add((int[])k.Clone());
     785
     786                int[] keyPlusOne = new int[k.Length];
     787                for (int i = 0; i < k.Length; i++)
     788                {
     789                    keyPlusOne[i] = k[i] + 1;
     790                }
     791
     792                byte[] key = intArrayToByteArray(keyPlusOne);
     793
     794                ValueKey tmpValue = new ValueKey();
     795                byte[] dec = sender.Decrypt(input, key, null);
     796                double val = costMaster.calculateCost(dec);
     797
     798                String keyStr = "";
     799                foreach (byte bb in key)
     800                {
     801                    keyStr += bb + ", ";
     802                }
     803
     804                tmpValue.keyArray = key;
     805                tmpValue.decryption = dec;
     806                tmpValue.key = keyStr;
     807                tmpValue.value = val;
     808                valList.Add(tmpValue);
     809
     810                k = shiftKey(k);
     811
     812            } while (!arrayEquals(k, first));
     813        }
     814
     815        private int[] shiftKey(int[] key)
     816        {
     817            int[] ret = new int[key.Length];
     818            ret[0] = key[key.Length - 1];
     819            for (int i = 1; i < ret.Length; i++)
     820            {
     821                ret[i] = key[i - 1];
     822            }
     823
     824            return ret;
     825        }
     826
     827        private ArrayList analysis(IControlEncryption sender, byte[] cipher, byte[,] cipherMatrix, byte[,] cribMatrix, int keylength)
     828        {
     829            ArrayList possibleList = new ArrayList();
     830            int[] key = new int[keylength];
     831            for (int i = 0; i < key.Length; i++)
     832            {
     833                key[i] = -1;
     834            }
     835
     836            int keyPosition = 0;
     837            Boolean end = false;
     838
     839            while (!end)
     840            {
     841                Boolean check = true;
     842                if (keyPosition == -1)
     843                {
     844                    end = true;
     845                    break;
     846                }
     847
     848                if (key[keyPosition] == -1)
     849                {
     850                    for (int i = 0; i < key.Length; i++)
     851                    {
     852                        Boolean inUse = false;
     853                        for (int j = 0; j < keyPosition; j++)
     854                        {
     855                            if (i == key[j])
     856                                inUse = true;
     857                        }
     858
     859                        if (!inUse)
     860                        {
     861                            key[keyPosition] = i;
     862                            break;
     863                        }
     864                    }
     865                }
     866                else
     867                {
     868                    Boolean incrementPosition = true;
     869
     870                    if (keyPosition == 0 && searchPosition != -1)
     871                    {
     872                        byte[] cipherCol = getColumn(cipherMatrix, key[keyPosition], key.Length);
     873                        byte[] cribCol = getColumn(cribMatrix, keyPosition, key.Length);
     874                        int tmpSearchPosition = searchPosition;
     875                        searchPosition = -1;
     876
     877                        if (containsAndCheckCribPosition(cipherCol, cribCol, tmpSearchPosition + 1))
     878                        {
     879                            keyPosition++;
     880                            check = false;
     881                            incrementPosition = false;
     882                        }
     883                    }
     884
     885                    if (incrementPosition)
     886                    {
     887                        Boolean inUse = true;
     888
     889                        while (inUse)
     890                        {
     891                            key[keyPosition] = key[keyPosition] + 1;
     892                            inUse = false;
     893
     894                            for (int j = 0; j < keyPosition; j++)
     895                            {
     896                                if (key[keyPosition] == key[j])
     897                                    inUse = true;
     898                            }
     899                        }
     900
     901                        if (key[keyPosition] >= key.Length)
     902                        {
     903                            key[keyPosition] = -1;
     904                            keyPosition--;
     905                            check = false;
     906                        }
     907                    }
     908                }
     909
     910                if (keyPosition == 0 && key[0] == -1)
     911                {
     912                    break;
     913                }
     914
     915                if (check)
     916                {
     917                    if (keyPosition >= 0 && keyPosition <= key.Length)
     918                    {
     919                        byte[] cipherCol = getColumn(cipherMatrix, key[keyPosition], key.Length);
     920                        byte[] cribCol = getColumn(cribMatrix, keyPosition, key.Length);
     921
     922                        if (containsAndCheckCribPosition(cipherCol, cribCol, 0))
     923                            keyPosition++;
     924
     925                        if (keyPosition == key.Length)
     926                        {
     927                            possibleList.Add(key.Clone());
     928
     929                            keyPosition--;
     930                            key[keyPosition] = -1;
     931                            keyPosition--;
     932                        }
     933
     934                        if (keyPosition == 0)
     935                        {
     936                            searchPosition = -1;
     937                        }
     938                    }
     939                }
     940            }
     941            return possibleList;
     942        }
     943
     944        private byte[] getColumn(byte[,] input, int column, int keylength)
     945        {
     946            byte[] output = new byte[input.Length / keylength];
     947            for (int i = 0; i < output.Length; i++)
     948            {
     949                output[i] = input[column, i];
     950            }
     951            return output;
     952        }
     953
     954        Boolean containsAndCheckCribPosition(byte[] one, byte[] two, int startSearchAt)
     955        {
     956            for (int i = startSearchAt; i < one.Length; i++)
     957            {
     958                if (one[i] == two[0])
     959                {
     960                    for (int j = 1; j < two.Length; j++)
     961                    {
     962                        if (i + j >= one.Length)
     963                        {
     964                            break;
     965                        }
     966                        if (searchPosition != -1)
     967                        {
     968                            // höchstens 2 Positionen nach links oder rechts
     969                            if (Math.Sqrt((searchPosition - i) * (searchPosition - i)) > 2)
     970                            {
     971                                break;
     972                            }
     973                        }
     974
     975                        if (two[j].Equals(new byte()))
     976                        {
     977                            if (searchPosition == -1)
     978                            {
     979                                searchPosition = i;
     980                            }
     981                            return true;
     982                        }
     983                        else
     984                        {
     985                            if (one[i + j] != two[j])
     986                            {
     987                                break;
     988                            }
     989
     990                            if (j == two.Length - 1)
     991
     992                                if (searchPosition == -1)
    482993                                {
    483                                     Output = vk.decryption;
     994                                    searchPosition = i;
    484995                                }
    485                                 // value_threshold = costList.Last.Value.value;
    486                                 break;
    487                             }
    488                             node = node.Next;
    489                             i++;
    490                         }//end while
    491                     }//end if
     996                            return true;
     997                        }
     998                    }
     999                }
     1000            }
     1001            return false;
     1002        }
     1003
     1004        private Boolean arrayEquals(int[] a, int[] b)
     1005        {
     1006            if (a.Length != b.Length) return false;
     1007            for (int i = 0; i < a.Length; i++)
     1008            {
     1009                if (a[i] != b[i])
     1010                    return false;
     1011            }
     1012            return true;
     1013        }
     1014
     1015        private int[] nextPossible(int[] input, int numberOfOnes)
     1016        {
     1017            Boolean found = false;
     1018            while (!found)
     1019            {
     1020                input = addBinOne(input);
     1021                if (count(input, 1) == numberOfOnes)
     1022                    found = true;
     1023            }
     1024            return input;
     1025        }
     1026
     1027        private int count(int[] array, int countThis)
     1028        {
     1029            int c = 0;
     1030            foreach (int i in array)
     1031            {
     1032                if (i == countThis)
     1033                    c++;
     1034            }
     1035            return c;
     1036        }
     1037
     1038        private int[] addBinOne(int[] input)
     1039        {
     1040            int i = input.Length - 1;
     1041            while (i >= 0 && input[i] == 1)
     1042            {
     1043                input[i] = 0;
     1044                i--;
     1045            }
     1046            if (i >= 0)
     1047                input[i] = 1;
     1048            return input;
     1049        }
     1050
     1051        private long binomial_iter(int n, int k)
     1052        {
     1053            long produkt = 1;
     1054            if (k > n / 2)
     1055                k = n - k;
     1056            for (int i = 1; i <= k; ++i)
     1057            {
     1058                produkt = produkt * n-- / i;
     1059            }
     1060            return produkt;
     1061        }
     1062
     1063        private int[] getDefaultBinaryKey(byte[] cipher, int keylength)
     1064        {
     1065            int offset = cipher.Length % keylength;
     1066            int[] binaryKey = new int[keylength];
     1067
     1068            for (int i = 0; i < keylength; i++)
     1069            {
     1070                if (i + offset < keylength)
     1071                {
     1072                    binaryKey[i] = 0;
    4921073                }
    4931074                else
    4941075                {
    495                     if (vk.value < costList.Last().value)
    496                     {
    497                         node = costList.First;
    498                         int i = 0;
    499                         while (node != null)
    500                         {
    501                             if (vk.value < node.Value.value)
    502                             {
    503                                 costList.AddBefore(node, vk);
    504                                 costList.RemoveLast();
    505                                 if (i == 0)
    506                                 {
    507                                     Output = vk.decryption;
    508                                 }
    509 
    510                                 // value_threshold = costList.Last.Value.value;
    511                                 break;
    512                             }
    513                             node = node.Next;
    514                             i++;
    515                         }//end while
    516                     }//end if
    517                 }
    518             }
    519         }
    520 
    521         #endregion
    522 
    523         #region INotifyPropertyChanged Member
    524 
    525         public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
    526 
    527         #endregion
    528 
    529         public void ProgressChanged(double value, double max)
    530         {
    531             if (OnPluginProgressChanged != null)
    532             {
    533                 OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
    534 
    535             }
    536         }
    537 
    538         #region cribAnalysis
    539 
    540         private List<Dingens> tablelist;
    541         public void cribAnalysis(IControlEncryption sender, byte[] crib, byte[] cipher)
    542         {
    543            
    544 
    545             if (crib != null && crib != null)
    546             {
    547                 foreach (int c in getKeyLength(crib, cipher))
    548                 {
    549                     GuiLogMessage("Possible Key-Length: " + c, NotificationLevel.Info);
    550                 }
    551             }
    552             else { GuiLogMessage("Missing crib or input!", NotificationLevel.Info); }
    553 
    554             // tmp-
    555             // ValueKey Liste list
    556             // für jeden Text einen ValueKey erstellen
    557             // Bsp:
    558             //ValueKey tmpValue = new ValueKey();
    559             //tmpValue.keyArray = key;
    560             //byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
    561             //double val = costMaster.calculateCost(dec);
    562 
    563             // Am Ende Liste von ValueKeys an update geben:
    564             // updateToplist(list);
    565 
    566             //  if (costMaster.getRelationOperator() == RelationOperator.LessThen)
    567 
    568             ValueKey tmpValue = new ValueKey();
    569             tablelist = new List<Dingens>();
    570             //tmpValue.keyArray = {2;3;4};
    571             //byte[] dec = sender.Decrypt(input, tmpValue.keyArray, null);
    572             System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
    573             //String one = "ZWYXTENTEISECHICHTIGEXSITEERHEITSMITLLILUNGXANXADEEXAGENTENXXSSXINTERNENDIICHERHEITSXWENSTESYXESELERDENXDOPPXDAGENTENXINXRENXEIGENENUTEIHENXVERMDZETYXESXWIRSTURXAEUSSERTXENXVORSICHGXBEIMXUMGANHEMITXSICHERTEITSRELEVANXAMXMATERIALXINGEHALTENYERMXRAHMENXDAGXMAULWURFJXSDXWIRDXDIESTICHERHEITSLLUFEXAUFXSIGEYCONXDREIXXESETZTYXDERGSRSTEXZUGANXISCHLUESSELONSTXDIFFUSITXYXABXSOFORICWIRDXZURXSXKHERUNGXDERONOMMUNIKATINAXDASXALTEROSTIVEXKRYPTRAYSTEMXCAETG";
    574             String two = "YXTENTEISEZWICHTIGEXSICHERHEITSMITTEILUNGXANXALLEXAGENTENXDESXINTERNENXSICHERHEITSDIENSTESYXESXWERDENXDOPPELAGENTENXINXDENXEIGENENXREIHENXVERMUTETYXESXWIRDZURXAEUSSERSTENXVORSICHTXBEIMXUMGANGXMITXSICHERHEITSRELEVANTEMXMATERIALXANGEHALTENYXIMXRAHMENXDERXMAULWURFJAGDXWIRDXDIEXSICHERHEITSSTUFEXAUFXSILLYCONXDREIXGESETZTYXDERXERSTEXZUGANGSSCHLUESSELXISTXDIFFUSIONYXABXSOFORTXWIRDXZURXSICHERUNGXDERXKOMMUNIKATIONXDASXALTERNATIVEXKRYPTOSYSTEMXCAETRAG";
    575             //double val = costMaster.calculateCost(Input);
    576             double val2 = costMaster.calculateCost(enc.GetBytes(two));
    577             if (costMaster.getRelationOperator() == RelationOperator.LessThen)
    578             {
    579                 GuiLogMessage(enc.GetString(crib), NotificationLevel.Debug);
    580             }
    581            
    582             PermutationGenerator per = new PermutationGenerator(2);
    583             cribAnalysis1(Crib, Input);
    584             ars.WaitOne();
    585 
    586             for (int i = 0; i < tablelist.Count; i++)
    587             {
    588                 for (int ix = 0; ix < tablelist[i].getCount();ix++ )
    589                 {
    590                     if (tablelist[i].getSize(ix) == 0)
    591                     {
    592                         tablelist.Remove(tablelist[i]);
    593                         i--;
     1076                    binaryKey[i] = 1;
     1077                }
     1078            }
     1079            if (binaryKey.Sum() == 0)
     1080            {
     1081                for (int i = 0; i < keylength; i++)
     1082                {
     1083                    binaryKey[i] = 1;
     1084                }
     1085            }
     1086
     1087            return binaryKey;
     1088        }
     1089
     1090        private byte[,] cipherToMatrix(byte[] cipher, int[] key)
     1091        {
     1092            int height = cipher.Length / key.Length;
     1093            if (cipher.Length % key.Length != 0)
     1094            {
     1095                height++;
     1096            }
     1097
     1098            byte[,] cipherMatrix = new byte[key.Length, height];
     1099            int pos = 0;
     1100
     1101            for (int a = 0; a < key.Length; a++)
     1102            {
     1103                for (int b = 0; b < height; b++)
     1104                {
     1105                    if ((b == height - 1) && (key[a] != 1))
     1106                    {
    5941107                        break;
    595                        
    596                     }
    597                 }
    598             }
    599             for (int i = 0; i < tablelist.Count; i++)
    600             {
    601                 GuiLogMessage(tablelist[i].getCount()+"Kawumm", NotificationLevel.Debug);
    602             }
    603 
    604             //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 } };
    605             LinkedList<ValueKey> valList = new LinkedList<ValueKey>();
    606             for (int x = 0; x < tablelist.Count; x++)
    607             {
    608                 int[,] key = tablelist[x].toint();
    609 
    610                 List<List<int>> final1 = per.returnlogicper(key);
    611                
    612 
    613                 for (int ix = 0; ix < final1.Count; ix++)
    614                 {
    615                     for (int iy = 0; iy < final1[ix].Count; iy++)
    616                     {
    617                         int[] key2 = final1[ix].ToArray();
    618                         byte[] key3 = new byte[key2.Length];
    619                         for (int i = 0; i < key2.Length; i++)
    620                         {
    621                             key3[i] = Convert.ToByte(key2[i]);
    622                         }
    623                         byte[] dec = sender.Decrypt(Input, key3, null);
    624                         GuiLogMessage(enc.GetString(dec), NotificationLevel.Debug);
    625                         double val3 = costMaster.calculateCost(dec);
    626 
    627                         ValueKey v = new ValueKey();
    628                         v.decryption = dec;
    629                         v.value = val3;
    630                         v.key = "";
    631                         v.keyArray = key3;
    632                         valList.AddFirst(v);
    633                        
    634                        
    635                         GuiLogMessage("" + val3, NotificationLevel.Debug);
    636                         int help = final1[ix][0];
    637                         final1[ix].Remove(final1[ix][0]);
    638                         final1[ix].Add(help);
    639 
    640                     }
    641                 }
    642             }
    643 
    644            // GuiLogMessage(""+val, NotificationLevel.Debug);
    645            
    646             GuiLogMessage("" + val2, NotificationLevel.Debug);
    647 
    648             // Am Ende Liste von ValueKeys an update geben:
    649            
    650             double best = Double.MinValue;
    651             list1 = getDummyLinkedList(best);
    652             valuequeue = Queue.Synchronized(new Queue());
    653             foreach (ValueKey v in valList)
    654             {
    655                 valuequeue.Enqueue(v);
    656             }
    657             list1 = valList;
    658             updateToplist(valList);
    659             showProgress(System.DateTime.Now, 1, 1);
    660             ProgressChanged(1, 1);           
    661 
    662             //  if (costMaster.getRelationOperator() == RelationOperator.LessThen)
    663 
    664 
    665         }
    666 
    667         private void cribAnalysis(byte[] crib, byte[] cipher)
    668         {
    669 
    670             if (crib != null && crib != null)
    671             {
    672                 foreach (int c in getKeyLength(crib, cipher))
    673                 {
    674                     Console.WriteLine("Possible Key-Length: " + c);
    675                 }
    676             }
    677             else { Console.WriteLine("Missing crib or input!"); }
    678         }
    679 
    680         private void cribAnalysis1(byte[] crib, byte[] cipher)
    681         {
    682             if (crib == null || cipher == null)
    683             {
    684                 Console.WriteLine("Crib or Cipher NULL");
    685                 return;
    686             }
    687 
    688             for (int keylength = 1; keylength < crib.Length; keylength++)
    689             {
    690                 byte[,] cipherM = cipherToMatrix(keylength, cipher);
    691                 byte[,] cribM = cribToMatrix(keylength, crib);
    692 
    693                 // Matrix in Console zeigen
    694                 if (keylength == 12)
    695                 {
    696                     int length = cipherM.Length / keylength;
    697                     System.Text.Encoding enc = System.Text.Encoding.ASCII;
    698                     for (int a = 0; a < keylength; a++)
    699                     {
    700 
    701                         for (int b = 0; b < length; b++)
    702                         {
    703                             if (cipherM[b, a] != null)
    704                                 Console.Write((char)cipherM[b, a]);
    705                         }
    706                         Console.WriteLine("");
    707                     }
    708                     Console.WriteLine("");
    709                 }
    710 
    711                 analyse1(keylength, cipherM, cribM);
    712             }
    713         }
    714 
    715         private void analyse1(int keylength, byte[,] cipherMatrix, byte[,] cribMatrix)
    716         {
    717             int cipherMatrixLength = cipherMatrix.Length / keylength;
    718             int cribMatrixHeight = cribMatrix.Length / keylength;
    719 
    720             ArrayList all = new ArrayList();
    721             Boolean found = true;
    722 
    723 
    724             int end = keylength;
    725             if (cribMatrixHeight > 1)
    726             {
    727                 byte newbyte = new byte();
    728                 for (int i = 0; i < keylength; i++)
    729                 {
    730                     if (cribMatrix[i, 1] == newbyte)
    731                     {
    732                         end = i;
    733                         break;
    734                     }
    735                 }
    736             }
    737 
    738 
    739             for (int x = 0; x < end; x++)
    740             {
    741                 ArrayList c = contains(x, keylength, cipherMatrix, cribMatrix);
    742                 if (c == null)
    743                 {
    744                     found = false;
    745                     break;
    746                 }
    747                 else
    748                 {
    749                     foreach (MiniCribPos m in c)
    750                     {
    751                         all.Add(m);
    752                     }
    753                 }
    754             }
    755 
    756             if (found == false)
    757             {
    758                 return;
    759             }
    760 
    761             else
    762             {
    763                 auswertenNeu(keylength, end, all, cribMatrix, cipherMatrix);
    764             }
    765 
    766         }
    767 
    768         private ArrayList contains(int cribColumn, int keylength, byte[,] cipherMatrix, byte[,] cribMatrix)
    769         {
    770             int cipherMatrixLength = cipherMatrix.Length / keylength;
    771             int cribMatrixHeight = cribMatrix.Length / keylength;
    772             byte newbyte = new byte();
    773 
    774             ArrayList allFound = null;
    775 
    776             for (int a = 0; a < keylength; a++)
    777             {
    778                 for (int b = 0; b < cipherMatrixLength; b++)
    779                 {
    780                     if (cribMatrix[cribColumn, 0].Equals(cipherMatrix[b, a]))
    781                     {
    782                         for (int y = 1; y < cribMatrixHeight; y++)
    783                         {
    784                             if (b + y < cipherMatrixLength)
    785                             {
    786                                 if (cribMatrix[cribColumn, y].Equals(newbyte))
    787                                 {
    788                                     //passendes gefunden und jetzt eintragen
    789                                     MiniCribPos found = new MiniCribPos(cribColumn, b, a);
    790 
    791                                     if (allFound == null)
    792                                     {
    793                                         allFound = new ArrayList();
    794                                     }
    795 
    796                                     allFound.Add(found);
    797 
    798 
    799                                 }
    800 
    801                                 else if (cribMatrix[cribColumn, y].Equals(cipherMatrix[b + y, a]))
    802                                 {
    803                                     if (y == cribMatrixHeight - 1)
    804                                     {
    805                                         //passendes gefunden und jetzt eintragen
    806                                         MiniCribPos found = new MiniCribPos(cribColumn, b, a);
    807 
    808                                         if (allFound == null)
    809                                         {
    810                                             allFound = new ArrayList();
    811                                         }
    812 
    813                                         allFound.Add(found);
    814                                     }
    815                                 }
    816                                 else
    817                                 {
    818                                     break;
    819                                 }
    820                             }
    821                             else
    822                             {
    823                                 break;
    824                             }
    825                         }
    826                     }
    827                 }
    828             }
    829             return allFound;
    830         }
    831 
    832         // found possible keylength with crib.
    833         // trys to decrypt with crib.
    834         private void auswerten(int keylength, int end, ArrayList all, byte[,] cribMatrix, byte[,] cipherMatrix)
    835         {
    836             Console.WriteLine("possible keylength: " + keylength);
    837             // weiter analysieren (möglichen text finden)
    838 
    839             //foreach (MiniCribPos abc in all)
    840             //{
    841             //    Console.WriteLine(abc.cribColumn + "(" + abc.xPos + "/" + abc.yPos + ")");
    842             //}
    843 
    844             Hashtable table = new Hashtable();
    845 
    846             foreach (MiniCribPos abc in all)
    847             {
    848                 if (table.ContainsKey(abc.xPos))
    849                 {
    850                     int value = (int)table[abc.xPos];
    851                     table.Remove(abc.xPos);
    852                     table.Add(abc.xPos, value + 1);
    853                 }
    854                 else
    855                 {
    856                     table.Add(abc.xPos, 1);
    857                 }
    858             }
    859 
    860             //höchste anzahl suchen
    861             int highest = 0;
    862             int amount = 0;
    863 
    864             IDictionaryEnumerator _enumerator = table.GetEnumerator();
    865             while (_enumerator.MoveNext())
    866             {
    867                 if (((int)_enumerator.Value) > amount)
    868                 {
    869                     amount = (int)_enumerator.Value;
    870                     highest = (int)_enumerator.Key;
    871                 }
    872             }
    873             //Console.WriteLine("highest pos: " + highest + " (" + amount + "x)");
    874 
    875             // ordnen versuchen
    876             Console.WriteLine("TOP:");
    877             for (int a = 0; a < keylength; a++)
    878             {
    879                 foreach (MiniCribPos m in all)
    880                 {
    881                     if (m.xPos == highest && m.cribColumn == a)
    882                     {
    883                         //Console.WriteLine(a + ": Zeile:" + m.yPos + " (enc)");
    884                     }
    885                 }
    886             }
    887 
    888             Console.WriteLine("");
    889             Console.WriteLine("+1");
    890             for (int a = 0; a < keylength; a++)
    891             {
    892                 foreach (MiniCribPos m in all)
    893                 {
    894                     if (m.xPos == highest + 1 && m.cribColumn == a)
    895                     {
    896                         Console.WriteLine(a + "* Zeile :" + m.yPos + " (enc)");
    897                     }
    898                 }
    899             }
    900 
    901             Console.WriteLine("");
    902             Console.WriteLine("-1");
    903             for (int a = 0; a < keylength; a++)
    904             {
    905                 foreach (MiniCribPos m in all)
    906                 {
    907                     if (m.xPos == highest - 1 && m.cribColumn == a)
    908                     {
    909                         Console.WriteLine(a + "* -Zeile : " + m.yPos + " (enc)");
    910                     }
    911                 }
    912             }
    913             Console.WriteLine("-----------");
    914 
    915             // Wenn MiniCribs mit nur einem Buchstaben vorhanden sind:
    916             if (end < keylength)
    917             {
    918                 int searchCol = highest;
    919                 Boolean searchColChanged = false;
    920                 for (int a = end; a < keylength; a++)
    921                 {
    922                     byte mybte = cribMatrix[a, 0];
    923                     Boolean found1 = false;
    924                     for (int b = 0; b < keylength; b++)
    925                     {
    926                         if ((cipherMatrix[searchCol, b] == mybte))
    927                         {
    928                             found1 = true;
    929                             Console.WriteLine(a + ": Zeile " + b + "   col:" + searchCol);
    930                         }
    931                     }
    932                     if (!found1)
    933                     {
    934                         if (!searchColChanged)
    935                         {
    936                             searchColChanged = true;
    937                             a--;
    938                             searchCol++;
    939                         }
    940                         else
    941                         {
    942                             break;
    943                         }
    944 
    945                     }
    946                 }
    947             }
    948         }
    949 
    950         private void auswertenNeu(int keylength, int end, ArrayList all, byte[,] cribMatrix, byte[,] cipherMatrix)
    951         {
    952             Console.WriteLine("possible keylength: " + keylength);
    953             // weiter analysieren (möglichen text finden)
    954 
    955             foreach (MiniCribPos abc in all)
    956             {
    957                 Console.WriteLine(abc.cribColumn + "(" + abc.xPos + "/" + abc.yPos + ")");
    958             }
    959 
    960             Hashtable table = new Hashtable();
    961 
    962             foreach (MiniCribPos abc in all)
    963             {
    964                 if (table.ContainsKey(abc.xPos))
    965                 {
    966                     int value = (int)table[abc.xPos];
    967                     table.Remove(abc.xPos);
    968                     table.Add(abc.xPos, value + 1);
    969                 }
    970                 else
    971                 {
    972                     table.Add(abc.xPos, 1);
    973                 }
    974             }
    975 
    976             //höchste anzahl suchen
    977             int highest = 0;
    978             int amount = 0;
    979 
    980             IDictionaryEnumerator _enumerator = table.GetEnumerator();
    981             while (_enumerator.MoveNext())
    982             {
    983                 if (((int)_enumerator.Value) > amount)
    984                 {
    985                     amount = (int)_enumerator.Value;
    986                     highest = (int)_enumerator.Key;
    987                 }
    988             }
    989             Console.WriteLine("highest: " + highest + ": " + amount + "x");
    990 
     1108                    }
     1109                    else
     1110                    {
     1111                        cipherMatrix[a, b] = cipher[pos++];
     1112                    }
     1113                }
     1114            }
     1115            return cipherMatrix;
     1116        }
     1117
     1118        private byte[,] cribToMatrix(byte[] crib, int keylength)
     1119        {
     1120            int height = crib.Length / keylength;
     1121            if (crib.Length % keylength != 0)
     1122            {
     1123                height++;
     1124            }
     1125
     1126            byte[,] cribMatrix = new byte[keylength, height];
    9911127            int pos = 0;
    992             amount = 0;
    993 
    994             Dingens ding = new Dingens(keylength);
    995             foreach (MiniCribPos m in all)
    996             {
    997                 if ((m.xPos == highest - 1 || m.xPos == highest || m.xPos == highest + 1))
    998                 {
    999                     ding.add(m.cribColumn, m.yPos, m.xPos - highest);
    1000                 }
    1001             }
    1002 
    1003             // Wenn MiniCribs mit nur einem Buchstaben vorhanden sind:
    1004             if (end < keylength)
    1005             {
    1006                 Boolean searchColChanged = false;
    1007                 for (int a = end; a < keylength; a++)
    1008                 {
    1009                     byte mybte = cribMatrix[a, 0];
    1010 
    1011                     for (int b = 0; b < keylength; b++)
    1012                     {
    1013                         if ((cipherMatrix[highest - 1, b] == mybte))
    1014                         {
    1015                             ding.add(a, b, -1);
    1016                         }
    1017                         if ((cipherMatrix[highest, b] == mybte))
    1018                         {
    1019                             ding.add(a, b, 0);
    1020                         }
    1021                         if ((cipherMatrix[highest + 1, b] == mybte))
    1022                         {
    1023                             ding.add(a, b, +1);
    1024                         }
    1025                     }
    1026                 }
    1027             }
    1028 
    1029             for (int i = 0; i < keylength; i++)
    1030             {
    1031                 if (ding.getSize(i) == 1)
    1032                 {
    1033                     int val = ding.getColumn(i)[0].getValue();
    1034                     int shift = ding.getColumn(i)[0].getShift();
    1035 
    1036                     for (int j = 0; j < keylength; j++)
    1037                     {
    1038                         if (i != j && ding.getSize(j) > 0)
    1039                         {
    1040                             Dingens2[] column = ding.getColumn(j);
    1041                             for (int a = 0; a < column.Length; a++)
    1042                             {
    1043                                 if (column[a].getValue() == val)
    1044                                 {
    1045                                     ding.delete(j, val);
    1046                                     //Console.WriteLine("Delete: " + j + "/" + val + "(" + shift + ")");
    1047                                 }
    1048                             }
    1049                         }
    1050                     }
    1051                 }
    1052             }
    1053 
    1054             for (int i = 0; i < keylength; i++)
    1055             {
    1056                 Console.WriteLine(i + " mögliche Zeilen der encMatrix: " + ding.getString(i));
    1057             }
    1058 
    1059             tablelist.Add(ding);
    1060             ars.Set();
    1061            
    1062         }
    1063        
    1064        
    1065 
    1066         #endregion
    1067 
    1068         #region
    1069 
    1070         public ArrayList getKeyLength(byte[] crib, byte[] cipher)
    1071         {
    1072 
    1073             ArrayList keylengths = new ArrayList();
    1074 
    1075             for (int i = 1; i < crib.Length; i++)
    1076             {
    1077                 byte[,] cipherM = cipherToMatrix(i, cipher);
    1078                 byte[,] cribM = cribToMatrix(i, crib);
    1079                 int[] analysed = analyse(i, cipherM, cribM);
    1080 
    1081                 for (int j = 0; j < analysed.Length; j++)
    1082                 {
    1083 
    1084                     if (analysed[j] != 0)
    1085                     {
    1086                         if (j == analysed.Length - 1)
    1087                         {
    1088                             keylengths.Add(i);
    1089                         }
    1090                     }
    1091                     else break;
    1092                 }
    1093 
    1094             }
    1095             return keylengths;
    1096 
    1097         }
    1098 
    1099         byte[,] cribToMatrix(int i, byte[] tmp)
    1100         {
    1101             int x = tmp.Length / i;
    1102             if (tmp.Length % i != 0)
    1103             {
    1104                 x++;
    1105             }
    1106             byte[,] arr = new byte[i, x];
    1107             int count = 0;
    1108 
    1109             for (int a = 0; a < x; a++)
    1110             {
    1111                 for (int b = 0; b < i; b++)
    1112                 {
    1113                     if (count < tmp.Length)
    1114                         arr[b, a] = tmp[count++];
    1115                 }
    1116             }
    1117             return arr;
    1118         }
    1119 
    1120         byte[,] cipherToMatrix(int i, byte[] tmp)
    1121         {
    1122             int length = tmp.Length / i;
    1123             int off = 0;
    1124             if (tmp.Length % i != 0)
    1125             {
    1126                 length++;
    1127                 off = (i * length) - tmp.Length;
    1128             }
    1129             byte[,] cipherMatrix = new byte[length, i];
    1130             int pos = 0;
    1131 
    1132             for (int a = 0; a < i; a++)
    1133             {
    1134                 for (int b = 0; b < length; b++)
    1135                 {
    1136                     if (b == length - 1)
    1137                     {
    1138                         if (a < off)
    1139                         {
    1140                             break;
    1141                         }
    1142                     }
    1143                     cipherMatrix[b, a] = tmp[pos];
    1144                     pos++;
    1145                 }
    1146             }
    1147             return cipherMatrix;
    1148         }
    1149 
    1150         int[] analyse(int i, byte[,] cipherMatrix, byte[,] cribMatrix)
    1151         {
    1152             int cipherMatrixLength = cipherMatrix.Length / i;
    1153             int cribMatrixHeight = cribMatrix.Length / i;
    1154             int[] poscount = new int[i];
    1155             ArrayList[] def = new ArrayList[i];
    1156             for (int a = 0; a < i; a++)
    1157             {
    1158                 def[a] = new ArrayList();
    1159             }
    1160 
    1161             byte newchar = new byte();
    1162             byte emptychar = new byte();
    1163             int count = 0;
    1164             for (int a = 0; a < i; a++)
    1165             {
    1166                 if (!cribMatrix[a, cribMatrixHeight - 1].Equals(emptychar))
    1167                 {
    1168                     count++;
    1169                 }
    1170                 else
    1171                 {
    1172                     poscount[a] = -1;
    1173                 }
    1174             }
    1175 
    1176             for (int x = 0; x < count; x++)
    1177             {
    1178                 for (int a = 0; a < i; a++)
    1179                 {
    1180                     for (int b = 0; b < cipherMatrixLength; b++)
    1181                     {
    1182                         if (cribMatrix[x, 0].Equals(cipherMatrix[b, a]))
    1183                         {
    1184                             int tmpA = a;
    1185                             int tmpB = b;
    1186 
    1187                             for (int y = 1; y < cribMatrixHeight; y++)
    1188                             {
    1189                                 tmpB++;
    1190                                 if (tmpB == cipherMatrixLength - 1)
    1191                                 {
    1192                                     if (cipherMatrix[tmpB, tmpA].Equals(newchar))
    1193                                     {
    1194                                         tmpB = 0;
    1195                                         tmpA++;
    1196                                     }
    1197                                 }
    1198 
    1199                                 if ((tmpB) < cipherMatrixLength)
    1200                                 {
    1201                                     if (cribMatrix[x, y].Equals(cipherMatrix[tmpB, tmpA]))
    1202                                     {
    1203                                         if (y.Equals(cribMatrixHeight - 1))
    1204                                         {
    1205                                             poscount[x]++;
    1206                                             def[x].Add(b);
    1207 
    1208                                         }
    1209                                     }
    1210                                     else
    1211                                     {
    1212                                         break;
    1213                                     }
    1214                                 }
    1215                             }
    1216                         }
    1217                     }
    1218                 }
    1219             }
    1220             return poscount;
    1221         }
    1222 
    1223         #endregion
    1224 
    1225         private void showProgress(DateTime startTime, long size, long sum)
     1128
     1129            for (int b = 0; b < height; b++)
     1130            {
     1131                for (int a = 0; a < keylength; a++)
     1132                {
     1133                    if (pos < crib.Length)
     1134                        cribMatrix[a, b] = crib[pos++];
     1135                }
     1136            }
     1137            return cribMatrix;
     1138        }
     1139
     1140        private void showProgressCribAnalysis(DateTime startTime, long size, long sum, long keysPerSec)
    12261141        {
    12271142            LinkedListNode<ValueKey> linkedListNode;
     
    12321147                TimeSpan elapsedtime = DateTime.Now.Subtract(startTime); ;
    12331148                TimeSpan elapsedspan = new TimeSpan(elapsedtime.Days, elapsedtime.Hours, elapsedtime.Minutes, elapsedtime.Seconds, 0);
    1234                    
    1235                
     1149
     1150
    12361151
    12371152                TimeSpan span = currentTime.Subtract(startTime);
     
    12431158                long allseconds = seconds + 60 * minutes + 60 * 60 * hours + 24 * 60 * 60 * days;
    12441159                if (allseconds == 0) allseconds = 1;
    1245                 long keysPerSec = sum / allseconds;
    12461160
    12471161                long keystodo = (size - sum);
    1248                
     1162
    12491163                long secstodo = keystodo / keysPerSec;
    12501164
     
    12661180                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).startTime.Content = "" + startTime;
    12671181                    ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).keysPerSecond.Content = "" + keysPerSec;
    1268                    
     1182
    12691183
    12701184                    if (endTime != (new DateTime(1970, 1, 1)))
    12711185                    {
    12721186                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).timeLeft.Content = "" + endTime.Subtract(DateTime.Now);
    1273                         ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).elapsedTime.Content = "" + elapsedspan ;
     1187                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).elapsedTime.Content = "" + elapsedspan;
    12741188                        ((TranspositionAnalyserQuickWatchPresentation)QuickWatchPresentation).endTime.Content = "" + endTime;
    12751189                    }
     
    13161230        }
    13171231
    1318        
     1232        private byte[] intArrayToByteArray(int[] input)
     1233        {
     1234            byte[] output = new byte[input.Length];
     1235            for (int i = 0; i < output.Length; i++)
     1236            {
     1237                output[i] = Convert.ToByte(input[i]);
     1238            }
     1239
     1240            return output;
     1241        }
     1242
     1243        #endregion
     1244
     1245        #region genetic analysis
    13191246
    13201247        private void geneticAnalysis(IControlEncryption sender)
     
    13231250
    13241251            valuequeue = Queue.Synchronized(new Queue());
    1325            
     1252
    13261253            int size = settings.Iterations;
    13271254            int keylength = settings.KeySize;
    13281255            int repeatings = settings.Repeatings;
    13291256
    1330             if (size < 2 || keylength < 2 || repeatings <1)
     1257            if (size < 2 || keylength < 2 || repeatings < 1)
    13311258            {
    13321259                GuiLogMessage("Check keylength and iterations", NotificationLevel.Error);
     
    13521279            DateTime startTime = DateTime.Now;
    13531280            DateTime lastUpdate = DateTime.Now;
    1354                
     1281
    13551282            ArrayList bestOf = null;
    13561283
     
    13581285            {
    13591286                ArrayList valList = new ArrayList();
    1360                
     1287
    13611288                for (int i = 0; i < 12; i++)
    13621289                {
     
    13861313                {
    13871314                    valList = updateValueKeyArrayList(valList, 12);
    1388              
     1315
    13891316
    13901317                    //valListe sortieren
     
    15991526                        updateToplist(list1);
    16001527                        showProgress(startTime, size * repeatings, it * size + iteration);
    1601                         ProgressChanged(it*size+ iteration, size*repeatings);
     1528                        ProgressChanged(it * size + iteration, size * repeatings);
    16021529                        lastUpdate = DateTime.Now;
    16031530                    }
     
    16131540            }
    16141541        }
     1542
     1543        #endregion
     1544
    16151545
    16161546        private ArrayList updateValueKeyArrayList(ArrayList list, int rest)
     
    17341664
    17351665    }
    1736     class MiniCribPos
    1737     {
    1738         public int cribColumn { get; set; }
    1739         public int xPos { get; set; }
    1740         public int yPos { get; set; }
    1741 
    1742         public MiniCribPos(int cribColumn, int xPos, int yPos)
    1743         {
    1744             this.cribColumn = cribColumn;
    1745             this.xPos = xPos;
    1746             this.yPos = yPos;
    1747         }
    1748     }
    1749 
    1750     class Dingens
    1751     {
    1752         Dingens2[,] dingens;
    1753         int length = 0;
    1754 
    1755         public Dingens(int length)
    1756         {
    1757             this.length = length;
    1758             dingens = new Dingens2[length, length];
    1759         }
    1760 
    1761         public void add(int column, int value, int shift)
    1762         {
    1763             if (column < length)
    1764             {
    1765                 for (int i = 0; i < length; i++)
    1766                 {
    1767                     if (dingens[column, i] == null)
    1768                     {
    1769                         dingens[column, i] = new Dingens2(value, shift);
    1770                         break;
    1771                     }
    1772                 }
    1773             }
    1774         }
    1775         public int getCount()
    1776         {
    1777             return length;
    1778         }
    1779         public int getSize(int column)
    1780         {
    1781             int count = 0;
    1782             if (column < length)
    1783             {
    1784                 for (int i = 0; i < length; i++)
    1785                 {
    1786                     if (dingens[column, i] != null)
    1787                     {
    1788                         count++;
    1789                     }
    1790                 }
    1791             }
    1792             return count;
    1793         }
    1794 
    1795         public void delete(int column, int value)
    1796         {
    1797             if (column < length)
    1798             {
    1799                 for (int i = 0; i < length; i++)
    1800                 {
    1801                     if (dingens[column, i] != null)
    1802                     {
    1803                         if (dingens[column, i].getValue() == value)
    1804                         {
    1805 
    1806                             dingens[column, i] = null;
    1807                         }
    1808                     }
    1809                 }
    1810             }
    1811         }
    1812 
    1813         public String getString(int column)
    1814         {
    1815             String output = "";
    1816             if (column < length)
    1817             {
    1818                 for (int i = 0; i < length; i++)
    1819                 {
    1820                     if (dingens[column, i] != null)
    1821                     {
    1822                         output = output + dingens[column, i].getValue() + "(s=" + dingens[column, i].getShift() + "),";
    1823                     }
    1824                 }
    1825             }
    1826             return output;
    1827         }
    1828 
    1829         public Dingens2[] getColumn(int column)
    1830         {
    1831             int size = 0;
    1832             for (int i = 0; i < length; i++)
    1833             {
    1834                 if (dingens[column, i] != null) size++;
    1835             }
    1836 
    1837             Dingens2[] columnArray = new Dingens2[size];
    1838             int count = 0;
    1839             for (int i = 0; i < length; i++)
    1840             {
    1841                 if (dingens[column, i] != null) columnArray[count++] = dingens[column, i];
    1842             }
    1843             return columnArray;
    1844         }
    1845         public int[,] toint()
    1846         {
    1847             int[,] res = new int[length, length];
    1848             for (int i = 0; i < length; i++)
    1849             {
    1850                 for (int ix = 0; ix < length; ix++)
    1851                 {
    1852                     res[i, ix] = 0;
    1853                 }
    1854             }
    1855 
    1856             for (int i = 0; i < dingens.GetLength(0); i++)
    1857             {
    1858                 for (int ix = 0; ix < dingens.GetLength(1); ix++)
    1859                 {
    1860                     if (dingens[i, ix] != null)
    1861                     {
    1862                         res[i, ix] = dingens[i, ix].getValue()+1;
    1863                     }
    1864                 }
    1865             }
    1866             return res;
    1867         }
    1868     }
    1869 
    1870     class Dingens2
    1871     {
    1872         int value;
    1873         int shift;
    1874 
    1875         public Dingens2(int value, int shift)
    1876         {
    1877             this.value = value;
    1878             this.shift = shift;
    1879         }
    1880 
    1881         public int getValue()
    1882         {
    1883             return value;
    1884         }
    1885 
    1886         public int getShift()
    1887         {
    1888             return shift;
    1889         }
    1890     }
    1891 
    18921666}
  • trunk/CrypPlugins/TranspositionAnalyser/TranspositionAnalyserSettings.cs

    r1365 r1985  
    3333                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Hidden)));
    3434                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Hidden)));
     35                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("CribSearchKeylength", Visibility.Hidden)));
    3536                        break;
    3637                case 1: TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("MaxLength", Visibility.Hidden)));
     
    4243                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Hidden)));
    4344                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Hidden)));
     45                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("CribSearchKeylength", Visibility.Visible)));
    4446                        break;
    4547                case 2: TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("MaxLength", Visibility.Hidden)));
     
    5153                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Repeatings", Visibility.Visible)));
    5254                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("Iterations", Visibility.Visible)));
     55                        TaskPaneAttributeChanged(this, new TaskPaneAttributeChangedEventArgs(new TaskPaneAttribteContainer("CribSearchKeylength", Visibility.Hidden)));
    5356                        break;
    5457            }
     
    189192        }
    190193
     194        private int cribSearchKeylength = 12;
     195        [PropertySaveOrder(10)]
     196        [TaskPaneAttribute("Maximum keylength for crib analysis", "Enter the maximum keylength for the crib based analysis.", null, 2, true, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "[0-9]{1,2}")]
     197        public int CribSearchKeylength
     198        {
     199            get { return cribSearchKeylength; }
     200            set
     201            {
     202                if (value != this.cribSearchKeylength) HasChanges = true;
     203                cribSearchKeylength = value;
     204                OnPropertyChanged("CribSearchKeylength");
     205            }
     206        }
     207
    191208
    192209        public bool HasChanges
Note: See TracChangeset for help on using the changeset viewer.