source: trunk/CrypPlugins/KeySearcher/KeySearcher.cs @ 2189

Last change on this file since 2189 was 2189, checked in by matkovic, 11 years ago

-added numeric separators

File size: 50.3 KB
RevLine 
[2010]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;
[1705]18using System.Diagnostics;
[2086]19using System.IO;
[409]20using System.Linq;
21using System.Text;
[1634]22using Cryptool.P2P;
[1698]23using Cryptool.P2P.Internal;
[409]24using Cryptool.PluginBase.Analysis;
25using Cryptool.PluginBase;
26using System.Windows.Controls;
27using System.ComponentModel;
28using Cryptool.PluginBase.Control;
[676]29using System.Collections;
[702]30using System.Collections.Generic;
[744]31using System.Threading;
32using System.Windows.Threading;
[1083]33using Cryptool.PluginBase.IO;
[1448]34using System.Numerics;
[1634]35using KeySearcher.Helper;
36using KeySearcher.P2P;
[2152]37using KeySearcher.P2P.Exceptions;
[1682]38using KeySearcherPresentation;
39using KeySearcherPresentation.Controls;
[2040]40using OpenCLNet;
[409]41
42namespace KeySearcher
[1027]43{   
44    [Author("Sven Rech, Nils Kopal, Raoul Falk, Dennis Nolte", "rech@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
[1161]45    [PluginInfo(false, "KeySearcher", "Bruteforces a decryption algorithm.", "KeySearcher/DetailedDescription/Description.xaml", "KeySearcher/Images/icon.png")]
[676]46    public class KeySearcher : IAnalysisMisc
[409]47    {
[939]48        /// <summary>
49        /// used for creating the TopList
50        /// </summary>
[819]51        private Queue valuequeue;
52        private double value_threshold;
[939]53        /// <summary>
54        /// the thread with the most keys left
55        /// </summary>
56        private int maxThread;
[1698]57        private readonly Mutex maxThreadMutex = new Mutex();
[2115]58        private ArrayList threadsStopEvents;
[819]59
[1727]60        public bool IsKeySearcherRunning;
[1682]61        private KeyQualityHelper keyQualityHelper;
[1698]62        private readonly P2PQuickWatchPresentation p2PQuickWatchPresentation;
63        private readonly LocalQuickWatchPresentation localQuickWatchPresentation;
[1634]64
[2040]65        private OpenCLManager oclManager = null;
[2146]66        private Mutex openCLPresentationMutex = new Mutex();
[2040]67
[1705]68        private readonly Stopwatch localBruteForceStopwatch;
69
[1698]70        private KeyPattern.KeyPattern pattern;
[1674]71        public KeyPattern.KeyPattern Pattern
[682]72        {
73            get
74            {
75                return pattern;
76            }
77            set
78            {
79                pattern = value;
[952]80                if ((settings.Key == null) || ((settings.Key != null) && !pattern.testWildcardKey(settings.Key)))
81                    settings.Key = pattern.giveInputPattern();
[682]82            }
83        }
84
[1634]85        internal bool stop;
[409]86
[2152]87        internal bool update;
88
[1083]89        #region IControlEncryption + IControlCost + InputFields
90
[939]91        #region IControlEncryption Members
92
93        private IControlEncryption controlMaster;
94        [PropertyInfo(Direction.ControlMaster, "Control Master", "Used for bruteforcing", "", DisplayLevel.Beginner)]
95        public IControlEncryption ControlMaster
96        {
97            get { return controlMaster; }
98            set
99            {
100                if (controlMaster != null)
101                {
102                    controlMaster.keyPatternChanged -= keyPatternChanged;
103                }
104                if (value != null)
105                {
[1674]106                    Pattern = new KeyPattern.KeyPattern(value.getKeyPattern());
[939]107                    value.keyPatternChanged += keyPatternChanged;
108                    controlMaster = value;
109                    OnPropertyChanged("ControlMaster");
110
111                }
112                else
113                    controlMaster = null;
114            }
115        }
116
117        #endregion
118
119        #region IControlCost Members
120
121        private IControlCost costMaster;
122        [PropertyInfo(Direction.ControlMaster, "Cost Master", "Used for cost calculation", "", DisplayLevel.Beginner)]
123        public IControlCost CostMaster
124        {
125            get { return costMaster; }
126            set
127            {
128                costMaster = value;
[1682]129                keyQualityHelper = new KeyQualityHelper(costMaster);
[939]130            }
131        }
132
133        #endregion
134
[1083]135        /* BEGIN: following lines are from Arnie - 2010.01.12 */
[1089]136        CryptoolStream csEncryptedData;
137        [PropertyInfo(Direction.InputData, "CS Encrypted Data", "Encrypted data out of an Encryption PlugIn", "", false, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, "")]
138        public virtual CryptoolStream CSEncryptedData
[1083]139        {
[1089]140            get { return this.csEncryptedData; }
[1083]141            set
142            {
[1089]143                if (value != this.csEncryptedData)
[1083]144                {
[1089]145                    this.csEncryptedData = value;
[1162]146                    this.encryptedData = GetByteFromCryptoolStream(value);
[1089]147                    OnPropertyChanged("CSEncryptedData");
148                }
149            }
150        }
151
152        byte[] encryptedData;
153        [PropertyInfo(Direction.InputData,"Encrypted Data","Encrypted data out of an Encryption PlugIn","",false,false,DisplayLevel.Beginner,QuickWatchFormat.Hex,"")]
154        public virtual byte[] EncryptedData
155        {
156            get { return this.encryptedData; }
157            set
158            {
159                if (value != this.encryptedData)
160                {
161                    this.encryptedData = value;
[1083]162                    OnPropertyChanged("EncryptedData");
163                }
164            }
165        }
166
167        /// <summary>
168        /// When the Input-Slot changed, set this variable to true, so the new Stream will be transformed to byte[]
169        /// </summary>
170        private byte[] GetByteFromCryptoolStream(CryptoolStream cryptoolStream)
171        {
[1162]172            byte[] encryptedByteData = null;
173
174            if (cryptoolStream != null)
[1083]175            {
176                CryptoolStream cs = new CryptoolStream();
177                cs.OpenRead(cryptoolStream.FileName);
[1089]178                encryptedByteData = new byte[cs.Length];
[1083]179                if(cs.Length > Int32.MaxValue)
180                    throw(new Exception("CryptoolStream length is longer than the Int32.MaxValue"));
[1089]181                cs.Read(encryptedByteData, 0, (int)cs.Length);
[1083]182            }
[1089]183            return encryptedByteData;
[1083]184        }
185
186        byte[] initVector;
187        [PropertyInfo(Direction.InputData, "Initialization Vector", "Initialization vector with which the data were encrypted", "", DisplayLevel.Beginner)]
[1089]188        public virtual byte[] InitVector
[1083]189        {
190            get { return this.initVector; }
191            set
192            {
193                if (value != this.initVector)
194                {
195                    this.initVector = value;
196                    OnPropertyChanged("InitVector");
197                }
198            }
199        }
200        /* END: Lines above are from Arnie - 2010.01.12 */
201
[1159]202        private ValueKey top1ValueKey;
203        public virtual ValueKey Top1
204        {
205            set { top1ValueKey = value; OnPropertyChanged("Top1Message"); OnPropertyChanged("Top1Key"); }
206        }
207
208        [PropertyInfo(Direction.OutputData, "Top1 Message", "The best message found", "", DisplayLevel.Beginner)]
209        public virtual byte[] Top1Message
210        {
211            get { return top1ValueKey.decryption; }
212        }
213        [PropertyInfo(Direction.OutputData, "Top1 Key", "The best key found", "", DisplayLevel.Beginner)]
[1160]214        public virtual byte[] Top1Key
[1159]215        {
[1160]216            get
217            {
[2010]218                if (top1ValueKey.key != null)
[1166]219                {
[2010]220                    return top1ValueKey.keya;
[1166]221                }
222                else
223                    return null;
[1160]224            }
[1159]225        }
226
[1083]227        #endregion
228
[676]229        #region IPlugin Members
[409]230
[676]231        public event StatusChangedEventHandler OnPluginStatusChanged;
[409]232
[676]233        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
[409]234
[676]235        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
[409]236
[819]237        private KeySearcherSettings settings;
[1682]238        private AutoResetEvent connectResetEvent;
[409]239
[676]240        public KeySearcher()
241        {
[1727]242            IsKeySearcherRunning = false;
[2183]243           
[2040]244            if (OpenCL.NumberOfPlatforms > 0)
245            {
246                oclManager = new OpenCLManager();
[2086]247                oclManager.AttemptUseBinaries = false;
248                oclManager.AttemptUseSource = true;
249                oclManager.RequireImageSupport = false;
[2092]250                var directoryName = Path.Combine(DirectoryHelper.DirectoryLocalTemp, "KeySearcher");
251                oclManager.BinaryPath = Path.Combine(directoryName, "openclbin");
[2086]252                oclManager.BuildOptions = "";
[2040]253                oclManager.CreateDefaultContext(0, DeviceType.ALL);
254            }
[2183]255
256            settings = new KeySearcherSettings(this, oclManager);
257
258            if (OpenCL.NumberOfPlatforms == 0)
[2158]259            {
260                settings.UseOpenCL = false;
261            }
[2171]262           
[1682]263            QuickWatchPresentation = new QuickWatch();
264            localQuickWatchPresentation = ((QuickWatch) QuickWatchPresentation).LocalQuickWatchPresentation;
265            p2PQuickWatchPresentation = ((QuickWatch)QuickWatchPresentation).P2PQuickWatchPresentation;
266            p2PQuickWatchPresentation.UpdateSettings(this, settings);
267
268            settings.PropertyChanged += SettingsPropertyChanged;
[2158]269            ((QuickWatch)QuickWatchPresentation).IsOpenCLEnabled = settings.UseOpenCL;
[1705]270
271            localBruteForceStopwatch = new Stopwatch();
[676]272        }
[409]273
[1682]274        void SettingsPropertyChanged(object sender, PropertyChangedEventArgs e)
275        {
276            p2PQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal,
[2158]277                                                             new Action(UpdateQuickwatchSettings));
[1682]278        }
279
[2158]280        void UpdateQuickwatchSettings()
[1682]281        {
282            ((QuickWatch)QuickWatchPresentation).IsP2PEnabled = settings.UsePeerToPeer;
[2146]283            ((QuickWatch)QuickWatchPresentation).IsOpenCLEnabled = settings.UseOpenCL;
[1682]284            p2PQuickWatchPresentation.UpdateSettings(this, settings);
285        }
286
[676]287        public ISettings Settings
288        {
289            get { return settings; }
290        }
[409]291
[676]292        public UserControl Presentation
[415]293        {
[1036]294            get { return QuickWatchPresentation; }
[676]295        }
[409]296
[676]297        public UserControl QuickWatchPresentation
298        {
[744]299            get;
300            private set;
[676]301        }
[409]302
[676]303        public void PreExecution()
304        {
[2152]305            update = false;
[676]306        }
[415]307
[1083]308        // because Encryption PlugIns were changed radical, the new StartPoint is here - Arnie 2010.01.12
[1089]309        public virtual void Execute()
[716]310        {
[1727]311            IsKeySearcherRunning = true;
[2161]312            localBruteForceStopwatch.Reset();
[1727]313
[1089]314            //either byte[] CStream input or CryptoolStream Object input
[1634]315            if (encryptedData != null || csEncryptedData != null) //to prevent execution on initialization
[1083]316            {
[1634]317                if (ControlMaster != null)
318                    process(ControlMaster);
[1083]319                else
320                {
321                    GuiLogMessage("You have to connect the KeySearcher with the Decryption Control!", NotificationLevel.Warning);
322                }
323            }
[715]324        }
325
[939]326        public void PostExecution()
327        {
328        }
329
330        public void Pause()
331        {
332        }
333
334        public void Stop()
335        {
[1727]336            IsKeySearcherRunning = false;
[939]337            stop = true;
338        }
339
340        public void Initialize()
341        {
[2040]342            settings.Initialize();
[939]343        }
344
345        public void Dispose()
346        {
347        }
348
349        #endregion
350
351        #region INotifyPropertyChanged Members
352
353        public event PropertyChangedEventHandler PropertyChanged;
354
355        public void OnPropertyChanged(string name)
356        {
357            if (PropertyChanged != null)
358            {
359                PropertyChanged(this, new PropertyChangedEventArgs(name));
360            }
361        }
362
363        #endregion
364
365        #region whole KeySearcher functionality
366
[843]367        private class ThreadStackElement
368        {
369            public AutoResetEvent ev;
370            public int threadid;
371        }
372
[908]373        #region code for the worker threads
[939]374
[819]375        private void KeySearcherJob(object param)
376        {
[2115]377            AutoResetEvent stopEvent = new AutoResetEvent(false);
378            threadsStopEvents.Add(stopEvent);
379
[819]380            object[] parameters = (object[])param;
[1674]381            KeyPattern.KeyPattern[] patterns = (KeyPattern.KeyPattern[])parameters[0];
[819]382            int threadid = (int)parameters[1];
[866]383            BigInteger[] doneKeysArray = (BigInteger[])parameters[2];
[2146]384            BigInteger[] openCLDoneKeysArray = (BigInteger[])parameters[3];
385            BigInteger[] keycounterArray = (BigInteger[])parameters[4];
386            BigInteger[] keysLeft = (BigInteger[])parameters[5];
387            IControlEncryption sender = (IControlEncryption)parameters[6];
388            int bytesToUse = (int)parameters[7];
389            Stack threadStack = (Stack)parameters[8];
390            bool useOpenCL = (bool)parameters[9];
[744]391
[2086]392            KeySearcherOpenCLCode keySearcherOpenCLCode = null;
[2143]393            KeySearcherOpenCLSubbatchOptimizer keySearcherOpenCLSubbatchOptimizer = null;
[2086]394            if (useOpenCL)
[2143]395            {
396                keySearcherOpenCLCode = new KeySearcherOpenCLCode(this, encryptedData, sender, CostMaster, 256 * 256 * 256 * 16);
[2161]397                keySearcherOpenCLSubbatchOptimizer = new KeySearcherOpenCLSubbatchOptimizer(settings.OpenCLMode, oclManager.CQ[settings.OpenCLDevice].Device.MaxWorkItemSizes.Aggregate(1, (x, y) => (x * (int)y)) / 8);
[2146]398                ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
399                {
400                    openCLPresentationMutex.WaitOne();
401                    ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.AmountOfDevices++;
402                    openCLPresentationMutex.ReleaseMutex();
403                }, null);
[2166]404                Thread.CurrentThread.Priority = ThreadPriority.AboveNormal;
[2143]405            }
[2086]406
[819]407            try
[676]408            {
[2086]409                while (patterns[threadid] != null)
[785]410                {
[2086]411                    BigInteger size = patterns[threadid].size();
[843]412                    keysLeft[threadid] = size;
[2086]413                   
[2061]414                    IKeyTranslator keyTranslator = ControlMaster.getKeyTranslator();
[2086]415                    keyTranslator.SetKeys(patterns[threadid]);
[2010]416
417                    bool finish = false;
418
[843]419                    do
[785]420                    {
[865]421                        //if we are the thread with most keys left, we have to share them:
[2086]422                        keyTranslator = ShareKeys(patterns, threadid, keysLeft, keyTranslator, threadStack);
423
424                        if (!useOpenCL)         //CPU
[843]425                        {
[2086]426                            finish = BruteforceCPU(keyTranslator, sender, bytesToUse);
427                        }
428                        else                    //OpenCL
429                        {
[1172]430                            try
431                            {
[2143]432                                finish = BruteforceOpenCL(keySearcherOpenCLCode, keySearcherOpenCLSubbatchOptimizer, keyTranslator, sender, bytesToUse, parameters);
[865]433                            }
[2086]434                            catch (Exception)
[1172]435                            {
[2086]436                                useOpenCL = false;
[2146]437                                ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
438                                {
439                                    openCLPresentationMutex.WaitOne();
440                                    ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.AmountOfDevices--;
441                                    openCLPresentationMutex.ReleaseMutex();
442                                }, null);
[2086]443                                continue;
[1172]444                            }
[843]445                        }
[2086]446                       
[2010]447                        int progress = keyTranslator.GetProgress();
[838]448
[2143]449                        if (!useOpenCL)
450                        {
451                            doneKeysArray[threadid] += progress;
452                            keycounterArray[threadid] += progress;
453                            keysLeft[threadid] -= progress;
454                        }
[1932]455
[2010]456                    } while (!finish && !stop);
[1932]457
[865]458                    if (stop)
459                        return;
[838]460
[843]461                    //Let's wait until another thread is willing to share with us:
[2086]462                    WaitForNewPattern(patterns, threadid, threadStack);
[843]463                }
[819]464            }
465            finally
466            {
467                sender.Dispose();
[2115]468                stopEvent.Set();
[819]469            }
470        }
[939]471
[2143]472        private unsafe bool BruteforceOpenCL(KeySearcherOpenCLCode keySearcherOpenCLCode, KeySearcherOpenCLSubbatchOptimizer keySearcherOpenCLSubbatchOptimizer, IKeyTranslator keyTranslator, IControlEncryption sender, int bytesToUse, object[] parameters)
[2086]473        {
[2143]474            int threadid = (int)parameters[1];
475            BigInteger[] doneKeysArray = (BigInteger[])parameters[2];
[2146]476            BigInteger[] openCLDoneKeysArray = (BigInteger[])parameters[3];
477            BigInteger[] keycounterArray = (BigInteger[])parameters[4];
478            BigInteger[] keysLeft = (BigInteger[])parameters[5];
[2086]479            try
480            {
481                Kernel bruteforceKernel = keySearcherOpenCLCode.GetBruteforceKernel(oclManager, keyTranslator);
[2143]482               
[2086]483                int deviceIndex = settings.OpenCLDevice;
484               
485                Mem userKey;
486                var key = keyTranslator.GetKey();
487                fixed (byte* ukp = key)
488                    userKey = oclManager.Context.CreateBuffer(MemFlags.USE_HOST_PTR, key.Length, new IntPtr((void*)ukp));
489
[2143]490                int subbatches = keySearcherOpenCLSubbatchOptimizer.GetAmountOfSubbatches(keyTranslator);
[2146]491                int subbatchSize = keyTranslator.GetOpenCLBatchSize() / subbatches;
492                ((QuickWatch) QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback) delegate
493                                                                    {
[2158]494                                                                        ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.workItems.Content = subbatchSize;
[2146]495                                                                    }, null);
[2161]496                //GuiLogMessage(string.Format("Now using {0} subbatches", subbatches), NotificationLevel.Info);
[2146]497               
[2143]498                float[] costArray = new float[subbatchSize];
499                Mem costs = oclManager.Context.CreateBuffer(MemFlags.READ_WRITE, costArray.Length * 4);
[2086]500
[2143]501                IntPtr[] globalWorkSize = { (IntPtr)subbatchSize };
[2086]502
[2143]503                keySearcherOpenCLSubbatchOptimizer.BeginMeasurement();
[2086]504
[2162]505                try
[2143]506                {
[2162]507                    for (int i = 0; i < subbatches; i++)
508                    {
509                        bruteforceKernel.SetArg(0, userKey);
510                        bruteforceKernel.SetArg(1, costs);
511                        bruteforceKernel.SetArg(2, i * subbatchSize);
512                        oclManager.CQ[deviceIndex].EnqueueNDRangeKernel(bruteforceKernel, 1, null, globalWorkSize, null);
513                        oclManager.CQ[deviceIndex].EnqueueBarrier();
[2143]514
[2162]515                        Event e;
516                        fixed (float* costa = costArray)
517                            oclManager.CQ[deviceIndex].EnqueueReadBuffer(costs, true, 0, costArray.Length * 4, new IntPtr((void*)costa), 0, null, out e);
[2143]518
[2162]519                        e.Wait();
[2143]520
[2162]521                        checkOpenCLResults(keyTranslator, costArray, sender, bytesToUse, i * subbatchSize);
[2143]522
[2162]523                        doneKeysArray[threadid] += subbatchSize;
524                        openCLDoneKeysArray[threadid] += subbatchSize;
525                        keycounterArray[threadid] += subbatchSize;
526                        keysLeft[threadid] -= subbatchSize;
[2143]527
[2162]528                        if (stop)
529                            return false;
530                    }
[2143]531
[2162]532                    keySearcherOpenCLSubbatchOptimizer.EndMeasurement();
533                }
534                finally
535                {
536                    costs.Dispose();
537                }
[2086]538            }
539            catch (Exception ex)
540            {
541                GuiLogMessage(ex.Message, NotificationLevel.Error);
542                GuiLogMessage("Bruteforcing with OpenCL failed! Using CPU instead.", NotificationLevel.Error);
543                throw new Exception("Bruteforcing with OpenCL failed!");
544            }
545
[2143]546            return !keyTranslator.NextOpenCLBatch();
547        }
548
549        private void checkOpenCLResults(IKeyTranslator keyTranslator, float[] costArray, IControlEncryption sender, int bytesToUse, int add)
550        {
[2086]551            var op = this.costMaster.getRelationOperator();
552            for (int i = 0; i < costArray.Length; i++)
553            {
554                float cost = costArray[i];
555                if (((op == RelationOperator.LargerThen) && (cost > value_threshold))
556                    || (op == RelationOperator.LessThen) && (cost < value_threshold))
557                {
[2143]558                    ValueKey valueKey = new ValueKey { value = cost, key = keyTranslator.GetKeyRepresentation(i + add) };
[2086]559                    valueKey.keya = keyTranslator.GetKeyFromRepresentation(valueKey.key);
560                    valueKey.decryption = sender.Decrypt(this.encryptedData, valueKey.keya, InitVector, bytesToUse);
561                    valuequeue.Enqueue(valueKey);
562                }
563            }
564        }
565
566        private bool BruteforceCPU(IKeyTranslator keyTranslator, IControlEncryption sender, int bytesToUse)
567        {
568            bool finish = false;
569            for (int count = 0; count < 256 * 256; count++)
570            {
571                byte[] keya = keyTranslator.GetKey();
572
573                if (!decryptAndCalculate(sender, bytesToUse, keya, keyTranslator))
574                    throw new Exception("Bruteforcing not possible!");
575
576                finish = !keyTranslator.NextKey();
577                if (finish)
578                    break;
579            }
580            return finish;
581        }
582
583        private IKeyTranslator ShareKeys(KeyPattern.KeyPattern[] patterns, int threadid, BigInteger[] keysLeft, IKeyTranslator keyTranslator, Stack threadStack)
584        {
585            BigInteger size;
586            if (maxThread == threadid && threadStack.Count != 0)
587            {
588                try
589                {
590                    maxThreadMutex.WaitOne();
591                    if (maxThread == threadid && threadStack.Count != 0)
592                    {
593                        KeyPattern.KeyPattern[] split = patterns[threadid].split();
594                        if (split != null)
595                        {
596                            patterns[threadid] = split[0];
597                            keyTranslator = ControlMaster.getKeyTranslator();
598                            keyTranslator.SetKeys(patterns[threadid]);
599
600                            ThreadStackElement elem = (ThreadStackElement)threadStack.Pop();
601                            patterns[elem.threadid] = split[1];
602                            elem.ev.Set();    //wake the other thread up                                   
603                            size = patterns[threadid].size();
604                            keysLeft[threadid] = size;
605                        }
606                        maxThread = -1;
607                    }
608                }
609                finally
610                {
611                    maxThreadMutex.ReleaseMutex();
612                }
613            }
614            return keyTranslator;
615        }
616
617        private void WaitForNewPattern(KeyPattern.KeyPattern[] patterns, int threadid, Stack threadStack)
618        {
619            ThreadStackElement el = new ThreadStackElement();
620            el.ev = new AutoResetEvent(false);
621            el.threadid = threadid;
622            patterns[threadid] = null;
623            threadStack.Push(el);
624            GuiLogMessage("Thread waiting for new keys.", NotificationLevel.Debug);
625            el.ev.WaitOne();
626            if (!stop)
627            {
628                GuiLogMessage("Thread waking up with new keys.", NotificationLevel.Debug);
629            }
630        }
631
[939]632        #region bruteforce methods
633
[2061]634        private bool decryptAndCalculate(IControlEncryption sender, int bytesToUse, byte[] keya, IKeyTranslator keyTranslator)
[865]635        {
[2010]636            ValueKey valueKey;
637
[865]638            try
639            {
[1162]640                if (this.encryptedData != null && this.encryptedData.Length > 0)
[1089]641                {
[1194]642                    valueKey.decryption = sender.Decrypt(this.encryptedData, keya, InitVector, bytesToUse);
[1089]643                }
644                else
645                {
[1162]646                    GuiLogMessage("Can't bruteforce empty input!", NotificationLevel.Error);
647                    return false;
[1089]648                }
[865]649            }
650            catch (Exception ex)
651            {
652                GuiLogMessage("Decryption is not possible: " + ex.Message, NotificationLevel.Error);
653                GuiLogMessage("Stack Trace: " + ex.StackTrace, NotificationLevel.Error);
654                return false;
655            }
656
657            try
658            {
659                valueKey.value = CostMaster.calculateCost(valueKey.decryption);
660            }
661            catch (Exception ex)
662            {
663                GuiLogMessage("Cost calculation is not possible: " + ex.Message, NotificationLevel.Error);
664                return false;
665            }
666
667            if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
668            {
669                if (valueKey.value > value_threshold)
670                {
[2010]671                    valueKey.key = keyTranslator.GetKeyRepresentation();
672                    valueKey.keya = (byte[])keya.Clone();
673                    valuequeue.Enqueue(valueKey);                   
[865]674                }
675            }
676            else
677            {
678                if (valueKey.value < value_threshold)
679                {
[2010]680                    valueKey.key = keyTranslator.GetKeyRepresentation();
681                    valueKey.keya = (byte[])keya.Clone();                 
[865]682                    valuequeue.Enqueue(valueKey);
683                }
684            }
685            return true;
686        }
687
[908]688        #endregion
689
[939]690        #endregion
691
[819]692        public void process(IControlEncryption sender)
693        {
[908]694            if (sender == null || costMaster == null)
695                return;
[971]696            if (!Pattern.testWildcardKey(settings.Key))
697            {
698                GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
699                return;
700            }
701            Pattern.WildcardKey = settings.Key;
[1634]702            this.sender = sender;
703
704            bruteforcePattern(Pattern);
[908]705        }
706
[1634]707        internal LinkedList<ValueKey> costList = new LinkedList<ValueKey>();
708        private int bytesToUse;
709        private IControlEncryption sender;
710        private DateTime beginBruteforcing;
[1682]711        private DistributedBruteForceManager distributedBruteForceManager;
[1634]712
[939]713        // main entry point to the KeySearcher
[1674]714        private LinkedList<ValueKey> bruteforcePattern(KeyPattern.KeyPattern pattern)
[908]715        {
[1634]716            beginBruteforcing = DateTime.Now;
[1244]717            GuiLogMessage("Start bruteforcing pattern '" + pattern.getKey() + "'", NotificationLevel.Debug);
718                       
[908]719            int maxInList = 10;
[1634]720            costList = new LinkedList<ValueKey>();
[908]721            fillListWithDummies(maxInList, costList);
[1634]722            valuequeue = Queue.Synchronized(new Queue());
[908]723
724            stop = false;
[952]725            if (!pattern.testWildcardKey(settings.Key))
[819]726            {
[908]727                GuiLogMessage("Wrong key pattern!", NotificationLevel.Error);
[971]728                return null;
[908]729            }
[819]730
[1682]731            // bytesToUse = 0;
[819]732
[908]733            try
734            {
735                bytesToUse = CostMaster.getBytesToUse();
736            }
737            catch (Exception ex)
738            {
739                GuiLogMessage("Bytes used not valid: " + ex.Message, NotificationLevel.Error);
[971]740                return null;
[908]741            }
[819]742
[1634]743            if (settings.UsePeerToPeer)
744            {
745                BruteForceWithPeerToPeerSystem();
746                return null;
747            }
748
749            return BruteForceWithLocalSystem(pattern);
750        }
751
752        private void BruteForceWithPeerToPeerSystem()
753        {
[2152]754            if (!update)
755            {
756                GuiLogMessage("Launching p2p based bruteforce logic...", NotificationLevel.Info);
[1698]757
[2152]758                try
759                {
760                    distributedBruteForceManager = new DistributedBruteForceManager(this, pattern, settings,
761                                                                                    keyQualityHelper,
762                                                                                    p2PQuickWatchPresentation);
763                    distributedBruteForceManager.Execute();
764                }
765                catch (NotConnectedException)
766                {
767                    GuiLogMessage("P2P not connected.", NotificationLevel.Error);
768                }
769                catch (KeySearcherStopException)
770                {
771                    update = true;
772                    return;
773                }
[1698]774            }
[2152]775            else
[1698]776            {
[2152]777                GuiLogMessage("Keysearcher Fullstop.Please Update your Version.", NotificationLevel.Error);
778                Thread.Sleep(3000);
[1698]779            }
[1634]780        }
781
[1682]782        internal LinkedList<ValueKey> BruteForceWithLocalSystem(KeyPattern.KeyPattern pattern, bool redirectResultsToStatisticsGenerator = false)
[1634]783        {
[2149]784            ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
785            {
786                openCLPresentationMutex.WaitOne();
787                ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.AmountOfDevices = 0;
788                openCLPresentationMutex.ReleaseMutex();
789            }, null);
790
[1705]791            if (!redirectResultsToStatisticsGenerator)
792            {
793                localQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action(SetStartDate));
794                localBruteForceStopwatch.Start();
795            }
796
[959]797            BigInteger size = pattern.size();
[1674]798            KeyPattern.KeyPattern[] patterns = splitPatternForThreads(pattern);
[2086]799            if (patterns == null || patterns.Length == 0)
800            {
801                GuiLogMessage("No ressources to BruteForce available. Check the KeySearcher settings!", NotificationLevel.Error);
802                throw new Exception("No ressources to BruteForce available. Check the KeySearcher settings!");
803            }
[908]804
805            BigInteger[] doneKeysA = new BigInteger[patterns.Length];
[2146]806            BigInteger[] openCLDoneKeysA = new BigInteger[patterns.Length];
[908]807            BigInteger[] keycounters = new BigInteger[patterns.Length];
808            BigInteger[] keysleft = new BigInteger[patterns.Length];
809            Stack threadStack = Stack.Synchronized(new Stack());
[2115]810            threadsStopEvents = ArrayList.Synchronized(new ArrayList());
[2146]811            StartThreads(sender, bytesToUse, patterns, doneKeysA, openCLDoneKeysA, keycounters, keysleft, threadStack);
[908]812
[2009]813            DateTime lastTime = DateTime.Now;
814
[908]815            //update message:
816            while (!stop)
817            {
[2143]818                Thread.Sleep(2000);
[908]819
[1634]820                updateToplist();
[908]821
822                #region calculate global counters from local counters
823                BigInteger keycounter = 0;
824                BigInteger doneKeys = 0;
[2146]825                BigInteger openCLdoneKeys = 0;
[908]826                foreach (BigInteger dk in doneKeysA)
827                    doneKeys += dk;
[2146]828                foreach (BigInteger dk in openCLDoneKeysA)
829                    openCLdoneKeys += dk;
[908]830                foreach (BigInteger kc in keycounters)
831                    keycounter += kc;
832                #endregion
833
834                if (keycounter > size)
835                    GuiLogMessage("There must be an error, because we bruteforced too much keys...", NotificationLevel.Error);
836
837                #region determination of the thread with most keys
838                if (size - keycounter > 1000)
[819]839                {
[1172]840                    try
841                    {
842                        maxThreadMutex.WaitOne();
843                        BigInteger max = 0;
844                        int id = -1;
845                        for (int i = 0; i < patterns.Length; i++)
846                            if (keysleft[i] != null && keysleft[i] > max)
847                            {
848                                max = keysleft[i];
849                                id = i;
850                            }
851                        maxThread = id;
852                    }
853                    finally
854                    {
855                        maxThreadMutex.ReleaseMutex();
856                    }
[819]857                }
[908]858                #endregion
[819]859
[2009]860                long keysPerSecond = (long)((long)doneKeys/(DateTime.Now - lastTime).TotalSeconds);
[2146]861                long openCLKeysPerSecond = (long)((long)openCLdoneKeys / (DateTime.Now - lastTime).TotalSeconds);
[2009]862                lastTime = DateTime.Now;
[1682]863                if (redirectResultsToStatisticsGenerator)
864                {
[2009]865                    distributedBruteForceManager.StatisticsGenerator.ShowProgress(costList, size, keycounter, keysPerSecond);
[1682]866                }
867                else
868                {
[2150]869                    showProgress(costList, size, keycounter, keysPerSecond);
[1682]870                }
[2150]871
872                //show OpenCL keys/sec:
[2151]873                var ratio = (double) openCLdoneKeys/(double) doneKeys;
[2150]874                ((QuickWatch)QuickWatchPresentation).Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
875                {
[2158]876                    ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondOpenCL.Content = String.Format("{0:N}", openCLKeysPerSecond);
877                    ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.keysPerSecondCPU.Content = String.Format("{0:N}", (keysPerSecond - openCLKeysPerSecond));
[2151]878                    ((QuickWatch)QuickWatchPresentation).OpenCLPresentation.ratio.Content = String.Format("{0:P}", ratio);
[2150]879                }, null);
[1682]880               
[819]881
[908]882                #region set doneKeys to 0
883                doneKeys = 0;
884                for (int i = 0; i < doneKeysA.Length; i++)
885                    doneKeysA[i] = 0;
[2146]886                openCLdoneKeys = 0;
887                for (int i = 0; i < openCLDoneKeysA.Length; i++)
888                    openCLDoneKeysA[i] = 0;
[908]889                #endregion
890
891                if (keycounter >= size)
892                    break;
893            }//end while
894
[2150]895            showProgress(costList, 1, 1, 1);
[2042]896
[908]897            //wake up all sleeping threads, so they can stop:
898            while (threadStack.Count != 0)
899                ((ThreadStackElement)threadStack.Pop()).ev.Set();
900
[2115]901            //wait until all threads finished:
902            foreach (AutoResetEvent stopEvent in threadsStopEvents)
903            {
904                stopEvent.WaitOne();
905            }
906
[1682]907            if (!stop && !redirectResultsToStatisticsGenerator)
[908]908                ProgressChanged(1, 1);
[971]909
[1244]910            /* BEGIN: For evaluation issues - added by Arnold 2010.03.17 */
911            TimeSpan bruteforcingTime = DateTime.Now.Subtract(beginBruteforcing);
912            StringBuilder sbBFTime = new StringBuilder();
913            if (bruteforcingTime.Days > 0)
914                sbBFTime.Append(bruteforcingTime.Days.ToString() + " days ");
915            if (bruteforcingTime.Hours > 0)
916            {
917                if (bruteforcingTime.Hours <= 9)
918                    sbBFTime.Append("0");
919                sbBFTime.Append(bruteforcingTime.Hours.ToString() + ":");
920            }
921            if (bruteforcingTime.Minutes <= 9)
922                sbBFTime.Append("0");
923            sbBFTime.Append(bruteforcingTime.Minutes.ToString() + ":");
924            if (bruteforcingTime.Seconds <= 9)
925                sbBFTime.Append("0");
926            sbBFTime.Append(bruteforcingTime.Seconds.ToString() + "-");
927            if (bruteforcingTime.Milliseconds <= 9)
928                sbBFTime.Append("00");
929            if (bruteforcingTime.Milliseconds <= 99)
930                sbBFTime.Append("0");
931            sbBFTime.Append(bruteforcingTime.Milliseconds.ToString());
932
933            GuiLogMessage("Ended bruteforcing pattern '" + pattern.getKey() + "'. Bruteforcing TimeSpan: " + sbBFTime.ToString(), NotificationLevel.Debug);
934            /* END: For evaluation issues - added by Arnold 2010.03.17 */
935
[971]936            return costList;
[908]937        }
938
[2061]939
940
[1705]941        private void SetStartDate()
942        {
943            localQuickWatchPresentation.startTime.Content = DateTime.Now.ToString("g", Thread.CurrentThread.CurrentCulture); ;
944        }
945
[2150]946        internal void showProgress(LinkedList<ValueKey> costList, BigInteger size, BigInteger keycounter, long keysPerSecond)
[908]947        {
[1030]948            System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
949
[908]950            LinkedListNode<ValueKey> linkedListNode;
[2146]951            ProgressChanged((double)keycounter / (double)size, 1.0);
[908]952
[2009]953            if (localQuickWatchPresentation.IsVisible && keysPerSecond != 0 && !stop)
[908]954            {
[2009]955                double time = (Math.Pow(10, BigInteger.Log((size - keycounter), 10) - Math.Log10(keysPerSecond)));
[908]956                TimeSpan timeleft = new TimeSpan(-1);
957
958                try
[843]959                {
[908]960                    if (time / (24 * 60 * 60) <= int.MaxValue)
[843]961                    {
[908]962                        int days = (int)(time / (24 * 60 * 60));
963                        time = time - (days * 24 * 60 * 60);
964                        int hours = (int)(time / (60 * 60));
965                        time = time - (hours * 60 * 60);
966                        int minutes = (int)(time / 60);
967                        time = time - (minutes * 60);
968                        int seconds = (int)time;
969
970                        timeleft = new TimeSpan(days, hours, minutes, (int)seconds, 0);
[843]971                    }
972                }
[908]973                catch
[819]974                {
[908]975                    //can not calculate time span
[819]976                }
[908]977
[1682]978                localQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
[819]979                {
[1705]980                    localQuickWatchPresentation.elapsedTime.Content = localBruteForceStopwatch.Elapsed;
[2189]981                    localQuickWatchPresentation.keysPerSecond.Content = String.Format("{0:0,0}", keysPerSecond);
[908]982                    if (timeleft != new TimeSpan(-1))
[819]983                    {
[1705]984                        localQuickWatchPresentation.timeLeft.Content = "" + timeleft;
[908]985                        try
[702]986                        {
[1705]987                            localQuickWatchPresentation.endTime.Content = "" + DateTime.Now.Add(timeleft);
[819]988                        }
[908]989                        catch
[819]990                        {
[1705]991                            localQuickWatchPresentation.endTime.Content = "in a galaxy far, far away...";
[819]992                        }
[702]993                    }
[908]994                    else
995                    {
[1705]996                        localQuickWatchPresentation.timeLeft.Content = "incalculable :-)";
997                        localQuickWatchPresentation.endTime.Content = "in a galaxy far, far away...";
[908]998                    }
[819]999
[1682]1000                    localQuickWatchPresentation.entries.Clear();
[908]1001                    linkedListNode = costList.First;
[2146]1002
[908]1003                    int i = 0;
1004                    while (linkedListNode != null)
1005                    {
1006                        i++;
[1030]1007
1008                        ResultEntry entry = new ResultEntry();
1009                        entry.Ranking = "" + i;
[2146]1010                        entry.Value = "" + Math.Round(linkedListNode.Value.value, 3);
[1030]1011                        entry.Key = linkedListNode.Value.key;
1012                        entry.Text = enc.GetString(linkedListNode.Value.decryption);
1013
[1682]1014                        localQuickWatchPresentation.entries.Add(entry);
[908]1015                        linkedListNode = linkedListNode.Next;
1016                    }
1017                }
1018                , null);
1019            }//end if
[1682]1020            else if (!stop && localQuickWatchPresentation.IsVisible)
[908]1021            {
1022
[1682]1023                localQuickWatchPresentation.Dispatcher.BeginInvoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
[908]1024                {
[1682]1025                    localQuickWatchPresentation.entries.Clear();
[2146]1026                    linkedListNode = costList.First;
[908]1027                    int i = 0;
[1030]1028
[908]1029                    while (linkedListNode != null)
[843]1030                    {
[908]1031                        i++;
[1030]1032
1033                        ResultEntry entry = new ResultEntry();
1034                        entry.Ranking = "" + i;
1035                        entry.Value = "" + Math.Round(linkedListNode.Value.value, 3);
1036                        entry.Key = linkedListNode.Value.key;
1037                        entry.Text = enc.GetString(linkedListNode.Value.decryption);
1038
[1682]1039                        localQuickWatchPresentation.entries.Add(entry);
[908]1040                        linkedListNode = linkedListNode.Next;
[843]1041                    }
[908]1042                }
1043                , null);
1044            }
1045        }
[843]1046
[939]1047        #region For TopList
1048
1049        private void fillListWithDummies(int maxInList, LinkedList<ValueKey> costList)
1050        {
1051            ValueKey valueKey = new ValueKey();
1052            if (this.costMaster.getRelationOperator() == RelationOperator.LessThen)
1053                valueKey.value = double.MaxValue;
1054            else
1055                valueKey.value = double.MinValue;
1056            valueKey.key = "dummykey";
1057            valueKey.decryption = new byte[0];
1058            value_threshold = valueKey.value;
1059            LinkedListNode<ValueKey> node = costList.AddFirst(valueKey);
1060            for (int i = 1; i < maxInList; i++)
1061            {
1062                node = costList.AddAfter(node, valueKey);
1063            }
1064        }
1065
[1682]1066        internal void IntegrateNewResults(LinkedList<ValueKey> updatedCostList)
[908]1067        {
[1682]1068            foreach (var valueKey in updatedCostList)
[1634]1069            {
[1682]1070                if (keyQualityHelper.IsBetter(valueKey.value, value_threshold))
[1634]1071                {
1072                    valuequeue.Enqueue(valueKey);
1073                }
1074            }
1075
1076            updateToplist();
1077        }
1078
1079        internal void updateToplist()
1080        {
[908]1081            LinkedListNode<ValueKey> node;
1082            while (valuequeue.Count != 0)
1083            {
1084                ValueKey vk = (ValueKey)valuequeue.Dequeue();
[1634]1085
1086                //if (costList.Contains(vk)) continue;
1087                var result = costList.Where(valueKey => valueKey.key == vk.key);
1088                if (result.Count() > 0)
1089                {
1090                    continue;
1091                }
1092
[908]1093                if (this.costMaster.getRelationOperator() == RelationOperator.LargerThen)
1094                {
1095                    if (vk.value > costList.Last().value)
[744]1096                    {
[908]1097                        node = costList.First;
1098                        while (node != null)
[780]1099                        {
[908]1100                            if (vk.value > node.Value.value)
[780]1101                            {
[1159]1102                                if (node == costList.First)
1103                                    Top1 = vk;
[908]1104                                costList.AddBefore(node, vk);
1105                                costList.RemoveLast();
1106                                value_threshold = costList.Last.Value.value;
1107                                break;
[780]1108                            }
[908]1109                            node = node.Next;
1110                        }//end while
1111                    }//end if
1112                }
1113                else
[951]1114                {
[908]1115                    if (vk.value < costList.Last().value)
1116                    {
1117                        node = costList.First;
1118                        while (node != null)
[819]1119                        {
[908]1120                            if (vk.value < node.Value.value)
[744]1121                            {
[1159]1122                                if (node == costList.First)
1123                                    Top1 = vk;
[908]1124                                costList.AddBefore(node, vk);
1125                                costList.RemoveLast();
1126                                value_threshold = costList.Last.Value.value;
1127                                break;
[744]1128                            }
[908]1129                            node = node.Next;
1130                        }//end while
[793]1131                    }//end if
[908]1132                }
1133            }
1134        }
[744]1135
[939]1136        #endregion
1137
[2146]1138        private void StartThreads(IControlEncryption sender, int bytesToUse, KeyPattern.KeyPattern[] patterns, BigInteger[] doneKeysA, BigInteger[] openCLDoneKeysA, BigInteger[] keycounters, BigInteger[] keysleft, Stack threadStack)
[908]1139        {
1140            for (int i = 0; i < patterns.Length; i++)
1141            {
1142                WaitCallback worker = new WaitCallback(KeySearcherJob);
1143                doneKeysA[i] = new BigInteger();
[2146]1144                openCLDoneKeysA[i] = new BigInteger();
[908]1145                keycounters[i] = new BigInteger();
[2086]1146                bool useOpenCL = false;
1147
1148                if (settings.UseOpenCL && (i == patterns.Length - 1))     //Last thread is the OpenCL thread
1149                    useOpenCL = true;
1150
[2146]1151                ThreadPool.QueueUserWorkItem(worker, new object[] { patterns, i, doneKeysA, openCLDoneKeysA, keycounters, keysleft, sender, bytesToUse, threadStack, useOpenCL });
[908]1152            }
1153        }
[785]1154
[1674]1155        private KeyPattern.KeyPattern[] splitPatternForThreads(KeyPattern.KeyPattern pattern)
[908]1156        {
[2086]1157            int threads = settings.CoresUsed;
1158            if (settings.UseOpenCL)
1159                threads++;
1160
1161            if (threads < 1)
1162                return null;
1163
1164            KeyPattern.KeyPattern[] patterns = new KeyPattern.KeyPattern[threads];
1165            if (threads > 1)
[908]1166            {
[1674]1167                KeyPattern.KeyPattern[] patterns2 = pattern.split();
[1135]1168                if (patterns2 == null)
1169                {
[1674]1170                    patterns2 = new KeyPattern.KeyPattern[1];
[1135]1171                    patterns2[0] = pattern;
1172                    return patterns2;
1173                }
[908]1174                patterns[0] = patterns2[0];
1175                patterns[1] = patterns2[1];
1176                int p = 1;
[2086]1177                threads -= 2;
1178
[908]1179                while (threads > 0)
1180                {
1181                    int maxPattern = -1;
1182                    BigInteger max = 0;
1183                    for (int i = 0; i <= p; i++)
1184                        if (patterns[i].size() > max)
[785]1185                        {
[908]1186                            max = patterns[i].size();
1187                            maxPattern = i;
[785]1188                        }
[1674]1189                    KeyPattern.KeyPattern[] patterns3 = patterns[maxPattern].split();
[1135]1190                    if (patterns3 == null)
1191                    {
[1674]1192                        patterns3 = new KeyPattern.KeyPattern[p+1];
[1135]1193                        for (int i = 0; i <= p; i++)
1194                            patterns3[i] = patterns[i];
1195                        return patterns3;
1196                    }
[908]1197                    patterns[maxPattern] = patterns3[0];
1198                    patterns[++p] = patterns3[1];
1199                    threads--;
1200                }
1201            }
1202            else
[2002]1203                patterns[0] = pattern;
[908]1204            return patterns;
[676]1205        }
[415]1206
[677]1207        private void keyPatternChanged()
1208        {
[1674]1209            Pattern = new KeyPattern.KeyPattern(controlMaster.getKeyPattern());
[677]1210        }
1211
[971]1212        // added by Arnie - 2009.12.07
1213        public delegate void BruteforcingEnded(LinkedList<ValueKey> top10List);
1214        /// <summary>
1215        /// This event gets thrown after Bruteforcing had ended. This is no evidence, that bruteforcing was successful.
1216        /// But when the returned List is filled, we have (at least a part) of the possible best keys
1217        /// </summary>
1218        public event BruteforcingEnded OnBruteforcingEnded;
1219
[951]1220        // added by Arnie -2009.12.02
1221        // for inheritance reasons
[1674]1222        public void BruteforcePattern(KeyPattern.KeyPattern pattern, byte[] encryptedData, byte[] initVector, IControlEncryption encryptControl, IControlCost costControl)
[951]1223        {
[1089]1224            /* Begin: New stuff because of changing the IControl data flow - Arnie 2010.01.18 */
[1162]1225            this.encryptedData = encryptedData;
1226            this.initVector = initVector;
[1089]1227            /* End: New stuff because of changing the IControl data flow - Arnie 2010.01.18 */
[1634]1228
1229            this.sender = encryptControl;
1230            LinkedList<ValueKey> lstRet = bruteforcePattern(pattern);
[971]1231            if(OnBruteforcingEnded != null)
1232                OnBruteforcingEnded(lstRet);
[951]1233        }
1234
[702]1235        #endregion
1236
[676]1237        public void GuiLogMessage(string message, NotificationLevel loglevel)
1238        {
1239            if (OnGuiLogNotificationOccured != null)
1240                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, loglevel));
1241        }
1242
[716]1243        public void ProgressChanged(double value, double max)
1244        {
1245            if (OnPluginProgressChanged != null)
1246            {
1247                OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
[744]1248
[716]1249            }
1250        }
1251
[939]1252        /// <summary>
1253        /// used for delivering the results from the worker threads to the main thread:
1254        /// </summary>
[971]1255        public struct ValueKey
[702]1256        {
1257            public double value;
1258            public String key;
[785]1259            public byte[] decryption;
[2010]1260            public byte[] keya;
[702]1261        };
[415]1262    }
[1030]1263
1264    /// <summary>
1265    /// Represents one entry in our result list
1266    /// </summary>
1267    public class ResultEntry
1268    {
1269        public string Ranking { get; set; }
1270        public string Value { get; set; }
1271        public string Key { get; set; }
1272        public string Text { get; set; }
1273
1274    }
[951]1275}
Note: See TracBrowser for help on using the repository browser.