Changeset 1932


Ignore:
Timestamp:
Sep 22, 2010, 5:27:14 PM (11 years ago)
Author:
Sven Rech
Message:

removed an optimization in keysearcher plugin, that didn't worked anymore and wasn't used anymore.
code is now more readable.

I will replace this by a much better optimization approach later (master project)

Location:
trunk
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPluginBase/Control/IControlEncryption.cs

    r1194 r1932  
    2828        byte[] Decrypt(byte[] ciphertext, byte[] key, byte[] IV);
    2929        string getKeyPattern();
    30         byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers);
     30        byte[] getKeyFromString(string key);
    3131        void changeSettings(string setting, object value);
    3232        IControlEncryption clone();
  • trunk/CrypPlugins/AES/AES.cs

    r1706 r1932  
    560560        }
    561561
    562         public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
     562        public byte[] getKeyFromString(string key)
    563563        {
    564564            int bytes = 0;
     
    575575                    break;
    576576            }
     577
    577578            byte[] bkey = new byte[bytes];
    578             int counter = 0;
    579             bool allocated = false;
    580579            for (int i = 0; i < bytes; i++)
    581580            {
     
    583582                {
    584583                    string substr = key.Substring(i * 3, 2);
    585                     if (!allocated && (substr[0] == '*' || substr[1] == '*'))
    586                     {
    587                         arrayPointers = new int[bytes];
    588                         for (int j = 0; j < bytes; j++)
    589                             arrayPointers[j] = -1;
    590                         arraySuccessors = new int[bytes];
    591                         arrayUppers = new int[bytes];
    592                         allocated = true;
    593                     }
    594                     if (substr[0] != '*' && substr[1] != '*')
    595                         bkey[i] = Convert.ToByte(substr, 16);
    596                     else if (substr[0] == '*' && substr[1] == '*')
    597                     {
    598                         bkey[i] = 0;
    599                         arrayPointers[counter] = i;
    600                         arraySuccessors[counter] = 1;
    601                         arrayUppers[counter] = 255;
    602                         counter++;
    603                     }
    604                     else if (substr[0] != '*' && substr[1] == '*')
    605                     {
    606                         bkey[i] = Convert.ToByte(substr[0] + "0", 16);
    607                         arrayPointers[counter] = i;
    608                         arraySuccessors[counter] = 1;
    609                         arrayUppers[counter] = Convert.ToByte(substr[0] + "F", 16);
    610                         counter++;
    611                     }
    612                     else if (substr[0] == '*' && substr[1] != '*')
    613                     {
    614                         bkey[i] = Convert.ToByte("0" + substr[1], 16);
    615                         arrayPointers[counter] = i;
    616                         arraySuccessors[counter] = 16;
    617                         arrayUppers[counter] = Convert.ToByte("F" + substr[1], 16);
    618                         counter++;
    619                     }
     584                    bkey[i] = Convert.ToByte(substr, 16);
    620585                }
    621586                catch (Exception ex)
  • trunk/CrypPlugins/DES/DES.cs

    r1195 r1932  
    565565        }
    566566
    567         public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
     567        public byte[] getKeyFromString(string key)
    568568        {
    569569            byte[] bkey = new byte[8];
    570             int counter = 0;
    571             bool allocated = false;
    572570
    573571            for (int i = 0; i <= 7; i++)
    574572            {
    575573                string substr = key.Substring(i * 3, 2);
    576 
    577                 if (!allocated && (substr[0] == '*' || substr[1] == '*'))
    578                 {
    579                     arrayPointers = new int[8];
    580                     for (int j = 0; j < 8; j++)
    581                         arrayPointers[j] = -1;
    582                     arraySuccessors = new int[8];
    583                     arrayUppers = new int[8];
    584                     allocated = true;
    585                 }
    586 
    587                 if (substr[0] != '*' && substr[1] != '*')
    588                     bkey[i] = Convert.ToByte(substr, 16);
    589                 else if (substr[0] == '*' && substr[1] == '*')
    590                 {
    591                     bkey[i] = 0;
    592                     arrayPointers[counter] = i;
    593                     arraySuccessors[counter] = 1;
    594                     arrayUppers[counter] = 255;
    595                     counter++;
    596                 }
    597                 else if (substr[0] != '*' && substr[1] == '*')
    598                 {
    599                     bkey[i] = Convert.ToByte(substr[0] + "0", 16);
    600                     arrayPointers[counter] = i;
    601                     arraySuccessors[counter] = 1;
    602                     arrayUppers[counter] = Convert.ToByte(substr[0] + "F", 16);
    603                     counter++;
    604                 }
    605                 else if (substr[0] == '*' && substr[1] != '*')
    606                 {
    607                     bkey[i] = Convert.ToByte("0" + substr[1], 16);
    608                     arrayPointers[counter] = i;
    609                     arraySuccessors[counter] = 16;
    610                     arrayUppers[counter] = Convert.ToByte("F" + substr[1], 16);
    611                     counter++;
    612                 }
    613             }
     574                bkey[i] = Convert.ToByte(substr, 16);
     575            }
     576
    614577            return bkey;
    615578        }
  • trunk/CrypPlugins/KeySearcher/KeyPattern/KeyPattern.cs

    r1674 r1932  
    259259        }
    260260
    261         /** used to jump to the next Key.         
     261        /** used to jump to the next key.         
    262262         * if nextWildcard == -1, we return false
    263263         * if nextWildcard == -2, we return true
     
    284284        }
    285285
     286        /** used to jump to the next key.
     287         */
     288        public bool nextKey()
     289        {
     290            return nextKey(-3);
     291        }
     292
    286293        public string getKey()
    287294        {
  • trunk/CrypPlugins/KeySearcher/KeySearcher.cs

    r1727 r1932  
    193193                if (top1ValueKey.key != null) //added by Arnold - 2010.02.22
    194194                {
    195                     int[] a = null, b = null, c = null;
    196                     return ControlMaster.getKeyFromString(top1ValueKey.key, ref a, ref b, ref c);
     195                    return ControlMaster.getKeyFromString(top1ValueKey.key);
    197196                }
    198197                else
     
    338337
    339338            KeyPattern.KeyPattern pattern = patterns[threadid];
    340 
    341             bool useKeyblocks = false;
    342 
     339           
    343340            try
    344341            {
     
    347344                    BigInteger size = pattern.size();
    348345                    keysLeft[threadid] = size;
    349                     int nextWildcard;
    350346
    351347                    do
     
    379375                        }
    380376
    381 
    382377                        ValueKey valueKey = new ValueKey();
    383                         int blocksize = 0;
    384                         nextWildcard = -3;
    385378                        try
    386379                        {
    387                             string key = "";
    388                             if (useKeyblocks)
    389                                 key = pattern.getKeyBlock(ref blocksize, ref nextWildcard);
    390                             if (key == null)
    391                                 useKeyblocks = false;
    392                             if (!useKeyblocks)
    393                                 key = pattern.getKey();
    394                             valueKey.key = key;
     380                            valueKey.key = pattern.getKey();
    395381                        }
    396382                        catch (Exception ex)
     
    400386                        }
    401387
    402                         int[] arrayPointers = null;
    403                         int[] arraySuccessors = null;
    404                         int[] arrayUppers = null;
    405                         byte[] keya = ControlMaster.getKeyFromString(valueKey.key, ref arrayPointers, ref arraySuccessors, ref arrayUppers);
    406                         if (keya == null)
    407                         {
    408                             useKeyblocks = false;
    409                             nextWildcard = -2;
    410                             continue;   //try again
    411                         }
    412 
    413                         if (arrayPointers == null)  //decrypt only one key
    414                         {
    415                             if (!decryptAndCalculate(sender, bytesToUse, ref valueKey, keya, 0, null))
    416                                 return;
    417                             doneKeysArray[threadid]++;
    418                             keycounterArray[threadid]++;
    419                             keysLeft[threadid]--;
    420                         }
    421                         else  //decrypt several keys
    422                         {
    423                             int counter = 0;
    424                             if (!bruteforceBlock(sender, bytesToUse, ref valueKey, keya, arrayPointers, arraySuccessors, arrayUppers, 0, ref counter, pattern))
    425                                 return;
    426                             doneKeysArray[threadid] += blocksize;
    427                             keycounterArray[threadid] += blocksize;
    428                             keysLeft[threadid] -= blocksize;
    429                         }
    430                     } while (pattern.nextKey(nextWildcard) && !stop);
     388                        byte[] keya = ControlMaster.getKeyFromString(valueKey.key);
     389
     390                        if (!decryptAndCalculate(sender, bytesToUse, ref valueKey, keya, 0, null))
     391                            return;
     392
     393                        doneKeysArray[threadid]++;
     394                        keycounterArray[threadid]++;
     395                        keysLeft[threadid]--;
     396
     397                    } while (pattern.nextKey() && !stop);
    431398
    432399                    if (stop)
     
    453420
    454421        #region bruteforce methods
    455 
    456         private bool bruteforceBlock(IControlEncryption sender, int bytesToUse, ref ValueKey valueKey, byte[] keya, int[] arrayPointers,
    457             int[] arraySuccessors, int[] arrayUppers, int arrayPointer, ref int counter, KeyPattern.KeyPattern pattern)
    458         {
    459             byte store = keya[arrayPointers[arrayPointer]];
    460             while (!stop)
    461             {
    462                 if (arrayPointer + 1 < arrayPointers.Length && arrayPointers[arrayPointer + 1] != -1)
    463                 {
    464                     if (!bruteforceBlock(sender, bytesToUse, ref valueKey, keya, arrayPointers, arraySuccessors, arrayUppers, arrayPointer + 1, ref counter, pattern))
    465                         return false;
    466                 }
    467                 else
    468                 {
    469                     if (!decryptAndCalculate(sender, bytesToUse, ref valueKey, keya, counter, pattern))
    470                         return false;
    471                 }
    472 
    473                 if (keya[arrayPointers[arrayPointer]] + arraySuccessors[arrayPointer] <= arrayUppers[arrayPointer])
    474                 {
    475                     keya[arrayPointers[arrayPointer]] += (byte)arraySuccessors[arrayPointer];
    476                     counter++;
    477                 }
    478                 else
    479                     break;
    480             }
    481             keya[arrayPointers[arrayPointer]] = store;
    482             if (stop)
    483                 return false;
    484             return true;
    485         }
    486422
    487423        private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, ref ValueKey valueKey, byte[] keya, int counter, KeyPattern.KeyPattern pattern)
  • trunk/CrypPlugins/SDES/SDES.cs

    r1804 r1932  
    638638        /// <param name="key"></param>
    639639        /// <returns></returns>
    640         public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
     640        public byte[] getKeyFromString(string key)
    641641        {
    642642            byte[] bkey = new byte[10];
  • trunk/CrypPlugins/Transposition/Transposition.cs

    r1194 r1932  
    11601160        }
    11611161
    1162         public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
     1162        public byte[] getKeyFromString(string key)
    11631163        {
    11641164            return null;
Note: See TracChangeset for help on using the changeset viewer.