Ignore:
Timestamp:
Oct 23, 2010, 7:39:00 PM (11 years ago)
Author:
Sven Rech
Message:

new key finding algorithm for KeySearcher

This update is really huge.

File:
1 edited

Legend:

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

    r2009 r2010  
    1 using System;
     1/*                             
     2   Copyright 2009 Sven Rech, Nils Kopal, Uni Duisburg-Essen
     3
     4   Licensed under the Apache License, Version 2.0 (the "License");
     5   you may not use this file except in compliance with the License.
     6   You may obtain a copy of the License at
     7
     8       http://www.apache.org/licenses/LICENSE-2.0
     9
     10   Unless required by applicable law or agreed to in writing, software
     11   distributed under the License is distributed on an "AS IS" BASIS,
     12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13   See the License for the specific language governing permissions and
     14   limitations under the License.
     15*/
     16
     17using System;
    218using System.Diagnostics;
    319using System.Linq;
     
    191207            get
    192208            {
    193                 if (top1ValueKey.key != null) //added by Arnold - 2010.02.22
    194                 {
    195                     return ControlMaster.getKeyFromString(top1ValueKey.key);
     209                if (top1ValueKey.key != null)
     210                {
     211                    return top1ValueKey.keya;
    196212                }
    197213                else
     
    344360                    BigInteger size = pattern.size();
    345361                    keysLeft[threadid] = size;
     362
     363                    KeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
     364                    keyTranslator.SetKeys(pattern);
     365
     366                    bool finish = false;
    346367
    347368                    do
     
    360381                                        patterns[threadid] = split[0];
    361382                                        pattern = split[0];
     383                                        keyTranslator = ControlMaster.getKeyTranslator();
     384                                        keyTranslator.SetKeys(pattern);
     385
    362386                                        ThreadStackElement elem = (ThreadStackElement)threadStack.Pop();
    363387                                        patterns[elem.threadid] = split[1];
     
    375399                        }
    376400
    377                         ValueKey valueKey = new ValueKey();
    378                         try
     401                        for (int count = 0; count < 256 * 256; count++)
    379402                        {
    380                             valueKey.key = pattern.getKey();
     403                            byte[] keya = keyTranslator.GetKey();
     404
     405                            if (!decryptAndCalculate(sender, bytesToUse, keya, keyTranslator))
     406                                return;
     407
     408                            finish = !keyTranslator.NextKey();
     409                            if (finish)
     410                                break;
    381411                        }
    382                         catch (Exception ex)
    383                         {
    384                             GuiLogMessage("Could not get next key: " + ex.Message, NotificationLevel.Error);
    385                             return;
    386                         }
    387 
    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);
     412                        int progress = keyTranslator.GetProgress();
     413
     414                        doneKeysArray[threadid] += progress;
     415                        keycounterArray[threadid] += progress;
     416                        keysLeft[threadid] -= progress;
     417
     418                    } while (!finish && !stop);
    398419
    399420                    if (stop)
     
    409430                    GuiLogMessage("Thread waiting for new keys.", NotificationLevel.Debug);
    410431                    el.ev.WaitOne();
    411                     GuiLogMessage("Thread waking up with new keys.", NotificationLevel.Debug);
    412                     pattern = patterns[threadid];
     432                    if (!stop)
     433                    {
     434                        GuiLogMessage("Thread waking up with new keys.", NotificationLevel.Debug);
     435                        pattern = patterns[threadid];
     436                    }
    413437                }
    414438            }
     
    421445        #region bruteforce methods
    422446
    423         private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, ref ValueKey valueKey, byte[] keya, int counter, KeyPattern.KeyPattern pattern)
    424         {
     447        private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, byte[] keya, KeyTranslator keyTranslator)
     448        {
     449            ValueKey valueKey;
     450
    425451            try
    426452            {
     
    434460                    return false;
    435461                }
    436                 //CryptoolStream cs = new CryptoolStream();
    437                 //if (this.CSEncryptedData == null)
    438                 //{
    439                 //    cs.OpenRead(this.EncryptedData);
    440                 //    valueKey.decryption = sender.Decrypt(this.EncryptedData, keya);
    441                 //}
    442                 //else
    443                 //{
    444                 //    cs.OpenRead(this.CSEncryptedData.FileName);
    445                 //    byte[] byteCS = new byte[cs.Length];
    446                 //    cs.Read(byteCS, 0, byteCS.Length);
    447                 //    //this.CSEncryptedData.Read(byteCS, 0, byteCS.Length);
    448                 //    valueKey.decryption = sender.Decrypt(byteCS, keya);
    449                 //}
    450 
    451                 //valueKey.decryption = sender.Decrypt(keya, bytesToUse);
    452462            }
    453463            catch (Exception ex)
     
    472482                if (valueKey.value > value_threshold)
    473483                {
    474                     if (pattern != null)
    475                         valueKey.key = pattern.getKey(counter);
    476                     valuequeue.Enqueue(valueKey);
     484                    valueKey.key = keyTranslator.GetKeyRepresentation();
     485                    valueKey.keya = (byte[])keya.Clone();
     486                    valuequeue.Enqueue(valueKey);                   
    477487                }
    478488            }
     
    481491                if (valueKey.value < value_threshold)
    482492                {
    483                     if (pattern != null)
    484                         valueKey.key = pattern.getKey(counter);
     493                    valueKey.key = keyTranslator.GetKeyRepresentation();
     494                    valueKey.keya = (byte[])keya.Clone();                 
    485495                    valuequeue.Enqueue(valueKey);
    486496                }
     
    514524        private DistributedBruteForceManager distributedBruteForceManager;
    515525
    516         // modified by Christian Arnold 2009.12.07 - return type LinkedList (top10List)
    517526        // main entry point to the KeySearcher
    518527        private LinkedList<ValueKey> bruteforcePattern(KeyPattern.KeyPattern pattern)
    519528        {
    520             //For evaluation issues - added by Arnold 2010.03.17
    521529            beginBruteforcing = DateTime.Now;
    522530            GuiLogMessage("Start bruteforcing pattern '" + pattern.getKey() + "'", NotificationLevel.Debug);
    523 
    524 
    525531                       
    526532            int maxInList = 10;
     
    10011007            public String key;
    10021008            public byte[] decryption;
     1009            public byte[] keya;
    10031010        };
    10041011    }
Note: See TracChangeset for help on using the changeset viewer.