Changeset 1475


Ignore:
Timestamp:
May 25, 2010, 12:01:46 PM (12 years ago)
Author:
weyers
Message:

TranspositionAnalyser analyse by crib first steps,PermutationGenerator extended

Location:
trunk/CrypPlugins/TranspositionAnalyser
Files:
2 edited

Legend:

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

    r859 r1475  
    33using System.Linq;
    44using System.Text;
     5
     6using Cryptool.PluginBase.Control;
     7using Cryptool.PluginBase.Miscellaneous;
    58
    69namespace TranspositionAnalyser
     
    125128        }
    126129
     130        private List<List<int>> listohneein;
     131        public List<List<int>> returnlogicper(int[,] key)
     132        {
     133            List<List<int>> listlist = erzeugen(key);
     134            List<int> listxein1 = xein1(erzeugen(key));
     135            List<int> list = rest(listxein1);
     136            listohneein = ohneein(erzeugen(key));
     137            int[] x = new int[list.Count];
     138
     139            for (int i = 0; i < list.Count; i++)
     140            {
     141                x[i] = list[i];
     142
     143            }
     144
     145            List<List<int>> allpermute = allper(x);
     146
     147            List<List<int>> finalkey1 = finalkey(allpermute, listohneein);
     148            List<List<int>> final1 = finale(finalkey1, listxein1);
     149            return final1;
     150        }
     151
     152        private List<List<int>> finale(List<List<int>> finalkey1, List<int> listxein)
     153        {
     154            List<List<int>> keysum = new List<List<int>>();
     155            for (int i = 0; i < finalkey1.Count; i++)
     156            {
     157                List<int> dummy = new List<int>();
     158                for (int ix = 0; ix < listxein.Count; ix++)
     159                {
     160                    dummy.Add(listxein[ix]);
     161                }
     162                for (int ix = 0; ix < dummy.Count; ix++)
     163                {
     164                    Console.Write(listxein[ix]);
     165                    if (dummy[ix] == 0)
     166                    {
     167                        dummy[ix] = finalkey1[i][0];
     168                        finalkey1[i].RemoveAt(0);
     169                    }
     170                }
     171                Console.WriteLine();
     172                keysum.Add(dummy);
     173            }
     174            return keysum;
     175        }
     176
     177        private List<List<int>> finalkey(List<List<int>> allpermute, List<List<int>> listohneein)
     178        {
     179            for (int i = 0; i < allpermute.Count; i++)
     180            {
     181                Boolean b = false;
     182                for (int ix = 0; ix < allpermute[i].Count; ix++)
     183                {
     184                    if (!listohneein[ix].Contains(allpermute[i][ix]))
     185                    {
     186                        // Console.Write(listohneein[ix][0]);
     187                        //Console.WriteLine(allpermute[i][ix]);
     188                        b = true;
     189                    }
     190                }
     191
     192                if (b)
     193                {
     194                    allpermute.RemoveAt(i);
     195                    i--;
     196                }
     197            }
     198            return allpermute;
     199        }
     200
     201        private List<List<int>> allper(int[] x)
     202        {
     203
     204            List<List<int>> allpermute = new List<List<int>>();
     205
     206            for (int i = 0; i < fak(x.Length); i++)
     207            {
     208                Boolean b = false;
     209                allpermute.Add(new List<int>());
     210                for (int ix = 0; ix < x.Length; ix++)
     211                {
     212                    allpermute[allpermute.Count - 1].Add(x[ix]);
     213                }
     214
     215                for (int ix = 0; ix < allpermute[allpermute.Count - 1].Count; ix++)
     216                {
     217                    if (!listohneein[ix].Contains(allpermute[allpermute.Count - 1][ix]))
     218                    {
     219                        //GuiLogMessage("You have to connect the Transposition Plugin to the Transpostion Analyzer Control!", NotificationLevel.Warning);
     220                        // Console.Write(listohneein[ix][0]);
     221                        //Console.WriteLine(allpermute[i][ix]);
     222                        b = true;
     223                    }
     224                }
     225                if (b)
     226                {
     227                    if (allpermute.Count > 0)
     228                        allpermute.RemoveAt(allpermute.Count - 1);
     229                }
     230                nextLexiPermutation(x);
     231            }
     232            return allpermute;
     233        }
     234        private int fak(int a)
     235        {
     236            int b = 1;
     237            for (int i = 1; i <= a; i++)
     238                b = b * i;
     239            return b;
     240        }
     241
     242        private List<List<int>> xein(List<List<int>> listlist1)
     243        {
     244            List<int> list = new List<int>();
     245            list.Add(0);
     246            for (int i = 0; i < listlist1.Count; i++)
     247            {
     248                if (listlist1[i].Count > 1)
     249                {
     250                    listlist1[i] = list;
     251                }
     252
     253            }
     254            return listlist1;
     255
     256        }
     257
     258        private List<int> xein1(List<List<int>> listlist1)
     259        {
     260            List<int> list = new List<int>();
     261
     262            for (int i = 0; i < listlist1.Count; i++)
     263            {
     264                if (listlist1[i].Count > 1)
     265                {
     266                    list.Add(0);
     267                }
     268                else { list.Add(listlist1[i][0]); }
     269            }
     270            return list;
     271
     272        }
     273
     274        private List<List<int>> ohneein(List<List<int>> listlist2)
     275        {
     276            for (int i = 0; i < listlist2.Count; i++)
     277            {
     278                if (listlist2[i].Count == 1)
     279                {
     280                    listlist2.RemoveAt(i);
     281                    i--;
     282                }
     283
     284            }
     285            return listlist2;
     286
     287        }
     288
     289        private List<List<int>> erzeugen(int[,] key)
     290        {
     291            List<List<int>> listlist = new List<List<int>>();
     292            for (int i = 0; i < key.GetLength(0); i++)
     293            {
     294                List<int> list = new List<int>();
     295
     296                for (int ix = 0; ix < key.GetLength(1); ix++)
     297                {
     298                    if (key[i, ix] != 0)
     299                    {
     300                        list.Add(key[i, ix]);
     301                    }
     302
     303                }
     304                listlist.Add(list);
     305            }
     306            return listlist;
     307        }
     308
     309        private List<int> rest(List<int> key)
     310        {
     311            List<int> list = new List<int>();
     312            for (int i = 1; i <= key.Count; i++)
     313            {
     314                Boolean b = true;
     315                for (int ix = 0; ix < key.Count; ix++)
     316                {
     317                    if (i == key[ix])
     318                    {
     319                        b = false;
     320                    }
     321                }
     322                if (b)
     323                {
     324                    list.Add(i);
     325                }
     326            }
     327            return list;
     328
     329        }
     330
     331        private int[] nextLexiPermutation(int[] s)
     332        {
     333            int i = -1, j = 0;
     334
     335            for (int x = s.Length - 2; x >= 0; x--)
     336                if (s[x] < s[x + 1])
     337                {
     338                    i = x;
     339                    break;
     340                }
     341
     342            if (-1 == i)
     343                return null;
     344
     345            for (int x = s.Length - 1; x > i; x--)
     346                if (s[x] > s[i])
     347                {
     348                    j = x;
     349                    break;
     350                }
     351
     352            // Swapping elements pointed by i and j;
     353            int temp = s[i];
     354            s[i] = s[j];
     355            s[j] = temp;
     356
     357            // Reversing elements after i
     358            Array.Reverse(s, i + 1, s.Length - (i + 1));
     359            return s;
     360        }
     361       
    127362    }
     363
     364
    128365   
    129366}
  • trunk/CrypPlugins/TranspositionAnalyser/TranspositionAnalyser.cs

    r1365 r1475  
    3131        private TranspositionAnalyserQuickWatchPresentation myPresentation;
    3232        private Random rd;
     33        private AutoResetEvent ars;
    3334
    3435        TranspositionAnalyserSettings settings;
     
    7778            QuickWatchPresentation = myPresentation;
    7879            myPresentation.doppelClick += new EventHandler(this.doppelClick);
     80            ars = new AutoResetEvent(false);
    7981        }
    8082
     
    9799                controlMaster = value;
    98100                OnPropertyChanged("ControlMaster");
    99 
    100             }
    101         }
     101            }
     102        }
     103
     104     
    102105
    103106        private IControlCost costMaster;
     
    146149        }
    147150
    148 
    149 
    150151        public UserControl Presentation
    151152        {
     
    193194        public void Stop()
    194195        {
     196            ars.Set();
    195197            stop = true;
    196198        }
     
    231233                {
    232234                    case 0: Output = costfunction_bruteforce(sender); GuiLogMessage("Starting Brute-Force Analysis", NotificationLevel.Info); break;
    233                     case 1: GuiLogMessage("Starting Analysis with crib", NotificationLevel.Info); cribAnalysis(this.crib, this.input); break;
     235                    case 1: GuiLogMessage("Starting Analysis with crib", NotificationLevel.Info); cribAnalysis(sender, this.crib, this.input); break;
    234236                    case 2: GuiLogMessage("Starting genetic analysis", NotificationLevel.Info); geneticAnalysis(sender); break;
    235237                }
     
    534536
    535537        #region cribAnalysis
    536         public void cribAnalysis(byte[] crib, byte[] cipher)
    537         {
     538
     539        private List<Dingens> tablelist;
     540        public void cribAnalysis(IControlEncryption sender, byte[] crib, byte[] cipher)
     541        {
     542           
    538543
    539544            if (crib != null && crib != null)
     
    545550            }
    546551            else { GuiLogMessage("Missing crib or input!", NotificationLevel.Info); }
    547         }
     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       
    5481064
    5491065        #endregion
     
    8321348
    8331349                ArrayList valList = new ArrayList();
    834 
     1350               
    8351351                for (int i = 0; i < 12; i++)
    8361352                {
     
    11961712
    11971713    }
     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    }
    11981869
    11991870}
Note: See TracChangeset for help on using the changeset viewer.