Changeset 2097


Ignore:
Timestamp:
Nov 15, 2010, 6:30:05 PM (11 years ago)
Author:
kohnen
Message:

Transposition Analyser Crib-Search:

  • bugfixes
  • performance increased
File:
1 edited

Legend:

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

    r1997 r2097  
    667667            int maxKeylength = settings.CribSearchKeylength;
    668668
    669             if (maxKeylength <= 1)
     669            if (crib == null)
     670            {
     671                GuiLogMessage("crib == null", NotificationLevel.Error);
     672                return;
     673            }
     674
     675            if (cipher == null)
     676            {
     677                GuiLogMessage("cipher == null", NotificationLevel.Error);
     678                return;
     679            }
     680
     681            if (crib.Length < 2)
     682            {
     683                GuiLogMessage("Crib is too short.", NotificationLevel.Error);
     684                return;
     685            }
     686
     687            if (maxKeylength < 1)
    670688            {
    671689                GuiLogMessage("Keylength must be greater than 1", NotificationLevel.Error);
     
    679697            }
    680698
    681             if (crib == null)
    682             {
    683                 GuiLogMessage("crib == null", NotificationLevel.Error);
    684                 return;
    685             }
    686 
    687             if (cipher== null)
    688             {
    689                 GuiLogMessage("cipher == null", NotificationLevel.Error);
    690                 return;
    691             }
    692 
    693             if (crib.Length < 2)
    694             {
    695                 GuiLogMessage("Crib is too short.", NotificationLevel.Error);
    696                 return;
    697             }
     699
    698700
    699701            for (int keylength = 2; keylength <= maxKeylength; keylength++)
     
    701703                sumBinKeys += binomial_iter(keylength, cipher.Length % keylength);
    702704            }
     705
     706            GuiLogMessage("KEYS INSG: " + sumBinKeys,NotificationLevel.Debug);
    703707
    704708            keysLastTenSecs = new int[10];
     
    707711            for (int keylength = 2; keylength <= maxKeylength && !stop; keylength++)
    708712            {
     713                GuiLogMessage("Keylength: " + keylength, NotificationLevel.Debug);
    709714                int[] binaryKey = getDefaultBinaryKey(cipher, keylength);
    710715                int[] firstKey = (int[])binaryKey.Clone();
     
    716721                    byte[,] cipherMatrix = cipherToMatrix(cipher, binaryKey);
    717722                    byte[,] cribMatrix = cribToMatrix(crib, keylength);
    718                     ArrayList possibleList = analysis(sender, cipher, cipherMatrix, cribMatrix, keylength);
    719 
    720                     Boolean eq;
    721                     foreach (int[] k in possibleList)
    722                     {
    723                         eq = false;
    724                         foreach (int[] kbest in bestlist)
    725                         {
    726                             if (arrayEquals(k, kbest))
    727                                 eq = true;
    728                         }
    729                         if (!eq)
    730                         {
    731                             addToBestList(sender, k);
     723
     724                    if(possibleCribForCipher(cipherMatrix,cribMatrix,keylength))
     725                    {
     726                        ArrayList possibleList = analysis(sender, cipher, cipherMatrix, cribMatrix, keylength);
     727
     728                        Boolean eq;
     729                        foreach (int[] k in possibleList)
     730                        {
     731                            eq = false;
     732                            foreach (int[] kbest in bestlist)
     733                            {
     734                                if (arrayEquals(k, kbest))
     735                                    eq = true;
     736                            }
     737                            if (!eq)
     738                            {
     739                                addToBestList(sender, k);
     740                            }
    732741                        }
    733742                    }
     
    754763                        showProgress(starttime, sumBinKeys, countBinKeys);
    755764                        ProgressChanged(countBinKeys, sumBinKeys);
    756 
    757                        
    758765                    }
    759766
     
    930937                        byte[] cribCol = getColumn(cribMatrix, keyPosition, key.Length);
    931938
    932                         if (containsAndCheckCribPosition(cipherCol, cribCol, 0))
     939                        int startSearchAt = 0;
     940                        if (searchPosition != -1)
     941                        {
     942                            startSearchAt = searchPosition;
     943                        }
     944
     945                        if (containsAndCheckCribPosition(cipherCol, cribCol, startSearchAt))
    933946                            keyPosition++;
    934947
     
    964977        Boolean containsAndCheckCribPosition(byte[] one, byte[] two, int startSearchAt)
    965978        {
    966             for (int i = startSearchAt; i < one.Length; i++)
     979            int max = one.Length - 1;
     980
     981            if (searchPosition != -1)
     982            {
     983                max = startSearchAt + 2;
     984                if (max >= one.Length)
     985                    max = startSearchAt;
     986            }
     987
     988            for (int i = startSearchAt; i <= max; i++)
    967989            {
    968990                if (one[i] == two[0])
     
    974996                            break;
    975997                        }
    976                         if (searchPosition != -1)
    977                         {
    978                             // höchstens 2 Positionen nach links oder rechts
    979                             if (Math.Sqrt((searchPosition - i) * (searchPosition - i)) > 2)
    980                             {
    981                                 break;
    982                             }
    983                         }
    984998
    985999                        if (two[j].Equals(new byte()))
     
    9911005                            return true;
    9921006                        }
     1007
    9931008                        else
    9941009                        {
     
    10121027        }
    10131028
     1029        Boolean contains(byte[] one, byte[] two)
     1030        {
     1031            for (int i = 0; i < one.Length; i++)
     1032            {
     1033                if (one[i] == two[0])
     1034                {
     1035                    for (int j = 1; j < two.Length; j++)
     1036                    {
     1037                        if (i + j >= one.Length)
     1038                        {
     1039                            break;
     1040                        }
     1041
     1042                        if (two[j].Equals(new byte()))
     1043                        {
     1044                            if (searchPosition == -1)
     1045                            {
     1046                                searchPosition = i;
     1047                            }
     1048                            return true;
     1049                        }
     1050
     1051                        else
     1052                        {
     1053                            if (one[i + j] != two[j])
     1054                            {
     1055                                break;
     1056                            }
     1057                            return true;
     1058                        }
     1059                    }
     1060                }
     1061            }
     1062            return false;
     1063        }
     1064
    10141065        private Boolean arrayEquals(int[] a, int[] b)
    10151066        {
     
    11461197            }
    11471198            return cribMatrix;
     1199        }
     1200
     1201        private Boolean possibleCribForCipher(byte[,] cipher, byte[,] crib, int keylength)
     1202        {
     1203            Boolean found;
     1204
     1205
     1206            for(int i=0; i<keylength; i++)
     1207            {
     1208                byte[] cribCol = getColumn(crib,i,keylength);
     1209                found = false;
     1210
     1211                for(int j=0; j< keylength; j++)
     1212                {
     1213                    byte[] cipherCol = getColumn(cipher, j, keylength);
     1214
     1215                    if (contains(cipherCol, cribCol))
     1216                    {
     1217                        found = true;
     1218                        break;
     1219                    }
     1220                }
     1221
     1222                if (!found)
     1223                    return false;
     1224            }
     1225
     1226            return true;
    11481227        }
    11491228
     
    12521331
    12531332        #endregion
     1333
     1334
     1335
    12541336
    12551337        #region genetic analysis
Note: See TracChangeset for help on using the changeset viewer.