Changeset 7247


Ignore:
Timestamp:
Oct 30, 2017, 5:47:57 PM (4 years ago)
Author:
heuser
Message:

Added full evaluation of the EnigmaBreaker

Location:
trunk/CrypPlugins/EnigmaBreaker
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/CrypPlugins/EnigmaBreaker/EnigmaAnalyzer.cs

    r7240 r7247  
    5959        AssignmentPresentation _presentation;
    6060
    61         private bool _stopped = false;
    62 
    63         private int rotorPos1 = 0;
    64         private int rotorPos2 = 0;
    65         private int rotorPos3 = 0;
    66 
    67         private int keys = 0;
    68         private DateTime lasttime = DateTime.Now;
    69 
    70         private List<analysisConfigSettings> analysisCandidates = new List<analysisConfigSettings>();
    71         private const int maxAnalysisEntries = 10; // should go in settings under "Analysis Options"
     61        private bool _stoppedOrFinished = false;
     62
     63        private int _rotorPos1 = 0;
     64        private int _rotorPos2 = 0;
     65        private int _rotorPos3 = 0;
     66
     67        private int _keys = 0;
     68        private DateTime _lasttime = DateTime.Now;
     69
     70        private List<analysisConfigSettings> _analysisCandidates = new List<analysisConfigSettings>();
     71        private const int _maxAnalysisEntries = 10; // should go in settings under "Analysis Options"
    7272        private const int _maxBestListEntries = 100;
     73
     74        // EVALUATION!
     75        private int _improvements = 0;
    7376
    7477        #endregion
     
    9194            };
    9295
     96            /*
    9397            if (_presentation.BestList.Count == 0)
    9498            {
     
    100104                _pluginFacade.BestPlaintext = entry.Text;
    101105                _pluginFacade.BestKey = entry.Key;
    102             }
     106            }*/
    103107
    104108            _pluginFacade.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     
    138142        private void UpdateKeysPerSec()
    139143        {
    140             if (DateTime.Now >= lasttime.AddMilliseconds(1000))
    141             {
    142                 var keysDispatcher = keys;
     144            if (DateTime.Now >= _lasttime.AddMilliseconds(1000))
     145            {
     146                var keysDispatcher = _keys;
    143147                _pluginFacade.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    144148                {
     
    154158                    }
    155159                }, null);
    156                 keys = 0;
    157                 lasttime = DateTime.Now;
     160                _keys = 0;
     161                _lasttime = DateTime.Now;
    158162            }
    159163        }
     
    168172
    169173            // Start the stopwatch
    170             Stopwatch sw = Stopwatch.StartNew();
     174            //Stopwatch sw = Stopwatch.StartNew();
    171175            //int trials = 0;
    172176
    173             for (int i = 0; i < 8 && !_stopped; i++)
     177            for (int i = 0; i < 8 && !_stoppedOrFinished; i++)
    174178            {
    175179                //Rotor 3 (slowest)
    176180                if (!includeRotor(i)) continue;
    177181                _settings.Rotor3 = i;
    178                 for (int j = 0; j < 8 && !_stopped; j++)
     182                for (int j = 0; j < 8 && !_stoppedOrFinished; j++)
    179183                {
    180184                    // Rotor 2 (middle)
     
    182186                    _settings.Rotor2 = j;
    183187
    184                     for (int k = 0; k < 8 && !_stopped; k++)
     188                    for (int k = 0; k < 8 && !_stoppedOrFinished; k++)
    185189                    {
    186190                        // Rotor 1 (fastest)
     
    201205                        else
    202206                            CheckKeyWithInitialRotorPos(text);
    203                         //trials++;
    204                         keys++;
    205207
    206208                        // print keys/sec in the ui
     
    218220
    219221            // Stop the stopwatch
    220             sw.Stop();
     222            //sw.Stop();
    221223
    222224            //string msg = String.Format("Processed {0} rotor permutations in {1}!", trials, sw.Elapsed.ToString());
     
    237239
    238240            // Start the stopwatch
    239             Stopwatch sw = Stopwatch.StartNew();
    240             int trials = 0;
     241            //Stopwatch sw = Stopwatch.StartNew();
     242            //int trials = 0;
    241243
    242244            // Rotor 1 positions (fastest)
    243             for (int l = 0; l < 26 && !_stopped; l++)
    244             {
    245                 for (int m = 0; m < 26 && !_stopped; m++)
    246                 {
    247                     for (int n = 0; n < 26 && !_stopped; n++)
     245            for (int l = 0; l < 26 && !_stoppedOrFinished; l++)
     246            {
     247                for (int m = 0; m < 26 && !_stoppedOrFinished; m++)
     248                {
     249                    for (int n = 0; n < 26 && !_stoppedOrFinished; n++)
    248250                    {
    249251                        checkKey(l, m, n, text);
    250                         trials++;
    251                         keys++;
     252                        //trials++;
    252253
    253254                        // print keys/sec in the ui
     
    261262
    262263            // Stop the stopwatch
    263             sw.Stop();
     264            //sw.Stop();
    264265
    265266            //string msg = String.Format("Processed {0} rotor positions for {1},{2},{3} in {4}!",
     
    275276        private string CheckKeyWithInitialRotorPos(string text)
    276277        {
    277             return checkKey(rotorPos1, rotorPos2, rotorPos3, text);
     278            return checkKey(_rotorPos1, _rotorPos2, _rotorPos3, text);
    278279        }
    279280
     
    293294            double newScore = calculateScore(result, _settings.SearchMethod);
    294295
    295             if (analysisCandidates.Count >= maxAnalysisEntries)
     296            _pluginFacade.IncrementDecryptionsCountForThread(0);
     297            _keys++;
     298
     299            if (_analysisCandidates.Count >= _maxAnalysisEntries)
    296300            {
    297301                // List is full, check if we need to remove one
    298                 if (newScore > analysisCandidates[0].Score)
    299                 {
    300                     double currentMax = analysisCandidates[analysisCandidates.Count - 1].Score;
     302                if (newScore > _analysisCandidates[0].Score)
     303                {
     304                    double currentMax = _analysisCandidates[_analysisCandidates.Count - 1].Score;
    301305
    302306                    analysisConfigSettings csetting = new analysisConfigSettings();
     
    311315                    csetting.InitialRotorPos = _settings.Alphabet[rotor3Pos].ToString() + _settings.Alphabet[rotor2Pos].ToString() + _settings.Alphabet[rotor1Pos].ToString();
    312316
    313                     analysisCandidates.Add(csetting);
    314                     analysisCandidates.Sort();
     317                    _analysisCandidates.Add(csetting);
     318                    _analysisCandidates.Sort();
    315319
    316320                    // remove the smallest one
    317                     analysisCandidates.RemoveAt(0);
    318 
    319 
     321                    _analysisCandidates.RemoveAt(0);
     322
     323                    // EVALUATION!
    320324                    if (newScore > currentMax)
    321325                    {
    322326                        // new best option
    323                         string status = String.Format("ANALYSIS: ==> Found better rotor settings: {0},{1},{2}; {3},{4},{5}; Key: {6}; I.C.={7} <==",
     327                        /*string status = String.Format("ANALYSIS: ==> Found better rotor settings: {0},{1},{2}; {3},{4},{5}; Key: {6}; I.C.={7} <==",
    324328                        (rotorEnum)csetting.Rotor3, (rotorEnum)csetting.Rotor2, (rotorEnum)csetting.Rotor1,
    325329                        csetting.Ring3.ToString("00"), csetting.Ring2.ToString("00"), csetting.Ring1.ToString("00"),
    326                         csetting.InitialRotorPos, newScore.ToString());
     330                        csetting.InitialRotorPos, newScore.ToString());*/
    327331                        //_pluginFacade.LogMessage(status, NotificationLevel.Info);
    328332                       
     
    333337
    334338                        AddNewBestListEntry(key, newScore, encrypt(csetting, text, csetting.PlugBoard));
    335                         printBestCandidates();
     339                        //printBestCandidates();
    336340
    337341                        // fire the event, so someting becomes visible..
    338                         if (OnIntermediateResult != null)
     342                        /*if (OnIntermediateResult != null)
    339343                        {
    340344                            OnIntermediateResult(this, new IntermediateResultEventArgs() { Result = result });
     345                        }*/
     346
     347                        // EVALUATION! increase the _improvements counter
     348                        _improvements++;
     349                        // only map the current plaintext into text space and
     350                        // compare its correctness, if the stopping option is
     351                        // active, a percentage is provided and the _improvements
     352                        // have reached the specified minimum (frequency)
     353                        if (_settings.StopIfPercentReached &&
     354                            _pluginFacade.MinimalCorrectPercentage != 0 &&
     355                            _improvements % _settings.ComparisonFrequency == 0)
     356                        {
     357                            // calculate string similarity between the current
     358                            // plaintext and the provided original plaintext
     359                            double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(result) * 100;
     360
     361                            Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + newScore);
     362
     363                            // stop the algorithm if the percentage is high enough
     364                            if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     365                            {
     366                                _pluginFacade.Finished = true;
     367                                _stoppedOrFinished = true;
     368                            }
    341369                        }
    342370                    }
     
    360388                csetting.InitialRotorPos = _settings.Alphabet[rotor3Pos].ToString() + _settings.Alphabet[rotor2Pos].ToString() + _settings.Alphabet[rotor1Pos].ToString();
    361389
    362                 analysisCandidates.Add(csetting);
    363                 analysisCandidates.Sort();
    364 
    365                 if (analysisCandidates.Count == maxAnalysisEntries)
    366                 {
    367                     printBestCandidates();
     390                _analysisCandidates.Add(csetting);
     391                _analysisCandidates.Sort();
     392
     393                string key = String.Format("{0}, {1}, {2} / {3}, {4}, {5} / {6} / {7}",
     394                    (rotorEnum)csetting.Rotor3, (rotorEnum)csetting.Rotor2, (rotorEnum)csetting.Rotor1,
     395                    csetting.Ring3.ToString(), csetting.Ring2.ToString(), csetting.Ring1.ToString(),
     396                    _pluginFacade.pB2String(csetting.PlugBoard), csetting.InitialRotorPos);
     397
     398                AddNewBestListEntry(key, newScore, encrypt(csetting, text, csetting.PlugBoard));
     399
     400                // EVALUATION! increase the _improvements counter
     401                _improvements++;
     402                // only map the current plaintext into text space and
     403                // compare its correctness, if the stopping option is
     404                // active, a percentage is provided and the _improvements
     405                // have reached the specified minimum (frequency)
     406                if (_settings.StopIfPercentReached &&
     407                    _pluginFacade.MinimalCorrectPercentage != 0 &&
     408                    _improvements % _settings.ComparisonFrequency == 0)
     409                {
     410                    // calculate string similarity between the current
     411                    // plaintext and the provided original plaintext
     412                    double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(result) * 100;
     413
     414                    Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + newScore);
     415
     416                    // stop the algorithm if the percentage is high enough
     417                    if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     418                    {
     419                        _pluginFacade.Finished = true;
     420                        _stoppedOrFinished = true;
     421                    }
     422                }
     423
     424                if (_analysisCandidates.Count == _maxAnalysisEntries)
     425                {
     426                    //printBestCandidates();
    368427
    369428                    // current best option
    370                     analysisConfigSettings bestOption = analysisCandidates[analysisCandidates.Count - 1];
    371 
    372                     string status = String.Format("ANALYSIS: Best candidates is filled. Best option so far: {0},{1},{2}; Key: {3}; I.C.={4}",
    373                     (rotorEnum)bestOption.Rotor3, (rotorEnum)bestOption.Rotor2, (rotorEnum)bestOption.Rotor1, bestOption.InitialRotorPos, bestOption.Score.ToString());
     429                    analysisConfigSettings bestOption = _analysisCandidates[_analysisCandidates.Count - 1];
     430
     431                    //string status = String.Format("ANALYSIS: Best candidates is filled. Best option so far: {0},{1},{2}; Key: {3}; I.C.={4}",
     432                    //(rotorEnum)bestOption.Rotor3, (rotorEnum)bestOption.Rotor2, (rotorEnum)bestOption.Rotor1, bestOption.InitialRotorPos, bestOption.Score.ToString());
    374433                    //_pluginFacade.LogMessage(status, NotificationLevel.Debug);
    375 
    376                     string key = String.Format("{0}, {1}, {2} / {3}, {4}, {5} / {6} / {7}",
    377                         (rotorEnum)csetting.Rotor3, (rotorEnum)csetting.Rotor2, (rotorEnum)csetting.Rotor1,
    378                         csetting.Ring3.ToString(), csetting.Ring2.ToString(), csetting.Ring1.ToString(),
    379                         _pluginFacade.pB2String(csetting.PlugBoard), csetting.InitialRotorPos);
    380 
    381                     AddNewBestListEntry(key, newScore, encrypt(csetting, text, csetting.PlugBoard));
    382434                       
    383435
    384436                    // fire the event, so someting becomes visible..
    385                     if (OnIntermediateResult != null)
     437                    /*if (OnIntermediateResult != null)
    386438                    {
    387439                        OnIntermediateResult(this, new IntermediateResultEventArgs() { Result = result });
    388                     }
     440                    }*/
    389441                }
    390442
     
    411463            {
    412464                // turn fast rotor
    413                 for (int i = 1; i <= _settings.Alphabet.Length && !_stopped; i++)
     465                for (int i = 1; i <= _settings.Alphabet.Length && !_stoppedOrFinished; i++)
    414466                {
    415467                    _core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, _settings.Reflector, i, 1, 1, 1, enigmaConfig.PlugBoard);
    416 
    417468
    418469                    int rotatedR1Pos;
     
    423474                        rotatedR1Pos = r1pos;
    424475
    425 
    426476                    string result = _core.Encrypt(rotatedR1Pos, r2pos, r3pos, 0, text);
    427 
    428477                    double newScore = calculateScore(result, _settings.SearchMethod);
    429478
    430                     keys++;
     479                    _pluginFacade.IncrementDecryptionsCountForThread(0);
     480                    _keys++;
    431481
    432482                    if (newScore > enigmaConfig.Score)
     
    443493
    444494                        AddNewBestListEntry(key, newScore, encrypt(enigmaConfig, text, enigmaConfig.PlugBoard));
     495
     496                        // EVALUATION! increase the _improvements counter
     497                        _improvements++;
     498                        // only map the current plaintext into text space and
     499                        // compare its correctness, if the stopping option is
     500                        // active, a percentage is provided and the _improvements
     501                        // have reached the specified minimum (frequency)
     502                        if (_settings.StopIfPercentReached &&
     503                            _pluginFacade.MinimalCorrectPercentage != 0 &&
     504                            _improvements % _settings.ComparisonFrequency == 0)
     505                        {
     506                            // calculate string similarity between the current
     507                            // plaintext and the provided original plaintext
     508                            double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(result) * 100;
     509
     510                            Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + newScore);
     511
     512                            // stop the algorithm if the percentage is high enough
     513                            if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     514                            {
     515                                _pluginFacade.Finished = true;
     516                                _stoppedOrFinished = true;
     517                            }
     518                        }
    445519                    }
    446520
     
    455529
    456530                // turn middle rotor
    457                 for (int i = 1; i <= _settings.Alphabet.Length && !_stopped; i++)
     531                for (int i = 1; i <= _settings.Alphabet.Length && !_stoppedOrFinished; i++)
    458532                {
    459533                    _core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, _settings.Reflector, enigmaConfig.Ring1, i, 1, 1, enigmaConfig.PlugBoard);
     
    468542                    string result = _core.Encrypt(r1pos, rotatedR2Pos, r3pos, 0, text);
    469543
    470                     keys++;
     544                    _pluginFacade.IncrementDecryptionsCountForThread(0);
     545                    _keys++;
    471546
    472547                    double newScore = calculateScore(result, _settings.SearchMethod);
     
    485560
    486561                        AddNewBestListEntry(key, newScore, encrypt(enigmaConfig, text, enigmaConfig.PlugBoard));
     562
     563                        // EVALUATION! increase the _improvements counter
     564                        _improvements++;
     565                        // only map the current plaintext into text space and
     566                        // compare its correctness, if the stopping option is
     567                        // active, a percentage is provided and the _improvements
     568                        // have reached the specified minimum (frequency)
     569                        if (_settings.StopIfPercentReached &&
     570                            _pluginFacade.MinimalCorrectPercentage != 0 &&
     571                            _improvements % _settings.ComparisonFrequency == 0)
     572                        {
     573                            // calculate string similarity between the current
     574                            // plaintext and the provided original plaintext
     575                            double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(result) * 100;
     576
     577                            Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + newScore);
     578
     579                            // stop the algorithm if the percentage is high enough
     580                            if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     581                            {
     582                                _pluginFacade.Finished = true;
     583                                _stoppedOrFinished = true;
     584                            }
     585                        }
    487586                    }
    488587
     
    495594            else
    496595            {
    497                 // in case the key is fixed, we search all combinations, i.e. 26*26*26
    498                 for (int i = 1; i <= _settings.Alphabet.Length && !_stopped; i++)
    499                 {
    500                     for (int j = 1; j <= _settings.Alphabet.Length && !_stopped; j++)
    501                     {
    502                         for (int k = 1; k <= _settings.Alphabet.Length && !_stopped; k++)
     596                // in case the initial pos is fixed, we search all combinations, i.e. 26*26*26
     597                for (int i = 1; i <= _settings.Alphabet.Length && !_stoppedOrFinished; i++)
     598                {
     599                    for (int j = 1; j <= _settings.Alphabet.Length && !_stoppedOrFinished; j++)
     600                    {
     601                        for (int k = 1; k <= _settings.Alphabet.Length && !_stoppedOrFinished; k++)
    503602                        {
    504603                            _core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, _settings.Reflector, k, j, i, 1, enigmaConfig.PlugBoard);
     
    506605                            double newScore = calculateScore(result, _settings.SearchMethod);
    507606
    508                             keys++;
     607                            _pluginFacade.IncrementDecryptionsCountForThread(0);
     608                            _keys++;
    509609
    510610                            if (newScore > enigmaConfig.Score)
     
    523623
    524624                                AddNewBestListEntry(key, newScore, encrypt(enigmaConfig, text, enigmaConfig.PlugBoard));
     625
     626                                // EVALUATION! increase the _improvements counter
     627                                _improvements++;
     628                                // only map the current plaintext into text space and
     629                                // compare its correctness, if the stopping option is
     630                                // active, a percentage is provided and the _improvements
     631                                // have reached the specified minimum (frequency)
     632                                if (_settings.StopIfPercentReached &&
     633                                    _pluginFacade.MinimalCorrectPercentage != 0 &&
     634                                    _improvements % _settings.ComparisonFrequency == 0)
     635                                {
     636                                    // calculate string similarity between the current
     637                                    // plaintext and the provided original plaintext
     638                                    double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(result) * 100;
     639
     640                                    Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + newScore);
     641
     642                                    // stop the algorithm if the percentage is high enough
     643                                    if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     644                                    {
     645                                        _pluginFacade.Finished = true;
     646                                        _stoppedOrFinished = true;
     647                                    }
     648                                }
    525649                            }
    526650
     
    559683            string tmp;
    560684            bool plugFound = false;
    561             int trials = 0;
     685            //int trials = 0;
    562686            int keys = 0;
    563687            string bestResult = encrypt(enigmaConfig, text, enigmaConfig.PlugBoard);
    564688            enigmaConfig.Score = calculateScore(bestResult, _settings.PlugSearchMethod);
    565689
    566             for (int n = 0; n < maxPlugs && !_stopped; n++)
     690            for (int n = 0; n < maxPlugs && !_stoppedOrFinished; n++)
    567691            {
    568692
     
    571695                tmp = enigmaConfig.PlugBoard;
    572696                plugFound = false;
    573                 trials = 0; //reset the counter, so we count each round individually
    574 
    575                 for (int i = 0; i < _settings.Alphabet.Length && !_stopped; i++)
    576                 {
    577                     for (int j = i + 1; j < _settings.Alphabet.Length && !_stopped; j++)
     697                // trials = 0; //reset the counter, so we count each round individually
     698
     699                for (int i = 0; i < _settings.Alphabet.Length && !_stoppedOrFinished; i++)
     700                {
     701                    for (int j = i + 1; j < _settings.Alphabet.Length && !_stoppedOrFinished; j++)
    578702                    {
    579703                        //create a "clean" plugboard
     
    587711                        {
    588712                            plugFound = plugFound | resolvePlugConflict(i, j, enigmaConfig, plugboard.ToString(), text);
    589                             trials += 3;
     713                            //trials += 3;
    590714                            keys += 3;
    591715                            continue;
     
    595719                        {
    596720                            plugFound = plugFound | resolvePlugConflict(j, i, enigmaConfig, plugboard.ToString(), text);
    597                             trials += 3;
     721                            //trials += 3;
    598722                            keys += 3;
    599723                            continue;
     
    606730                        string result = encrypt(enigmaConfig, text, plugboard.ToString());
    607731                        double newScore = calculateScore(result, _settings.PlugSearchMethod);
    608                         trials++;
     732
     733                        //trials++;
     734                        _pluginFacade.IncrementDecryptionsCountForThread(0);
    609735                        keys++;
    610736
     
    623749                            // default is the IC Score (index of coincidence)
    624750                            double GeneralSearchMethodScore = calculateScore(result, _settings.SearchMethod);
    625 
    626                             AddNewBestListEntry(key, GeneralSearchMethodScore, encrypt(enigmaConfig, text, enigmaConfig.PlugBoard));
     751                            string newBestPlaintext = encrypt(enigmaConfig, text, enigmaConfig.PlugBoard);
     752
     753                            AddNewBestListEntry(key, GeneralSearchMethodScore, newBestPlaintext);
     754
     755                            // EVALUATION! increase the _improvements counter
     756                            _improvements++;
     757                            // only map the current plaintext into text space and
     758                            // compare its correctness, if the stopping option is
     759                            // active, a percentage is provided and the _improvements
     760                            // have reached the specified minimum (frequency)
     761                            if (_settings.StopIfPercentReached &&
     762                                _pluginFacade.MinimalCorrectPercentage != 0 &&
     763                                _improvements % _settings.ComparisonFrequency == 0)
     764                            {
     765                                // calculate string similarity between the current
     766                                // plaintext and the provided original plaintext
     767                                double currentlyCorrect = _pluginFacade.CorrectPlaintextInput.CalculateSimilarity(newBestPlaintext) * 100;
     768
     769                                Console.WriteLine("currentlyCorrect: " + currentlyCorrect + "% - best score:" + GeneralSearchMethodScore);
     770
     771                                // stop the algorithm if the percentage is high enough
     772                                if (currentlyCorrect >= _pluginFacade.MinimalCorrectPercentage)
     773                                {
     774                                    _pluginFacade.Finished = true;
     775                                    _stoppedOrFinished = true;
     776                                }
     777                            }
    627778                        }
    628779
     
    636787                _pluginFacade.UpdateDisplayEnd(Resources.PlugsCaption);
    637788
    638                 string msg = String.Format("ANALYSIS: Plugs setting in round {0} after {1} trials: {2} | {3},{4},{5} | {6},{7},{8} | {9} | {10}",
     789                /*string msg = String.Format("ANALYSIS: Plugs setting in round {0} after {1} trials: {2} | {3},{4},{5} | {6},{7},{8} | {9} | {10}",
    639790                    (n + 1), trials, enigmaConfig.Score.ToString(),
    640791                    (rotorEnum)enigmaConfig.Rotor3, (rotorEnum)enigmaConfig.Rotor2, (rotorEnum)enigmaConfig.Rotor1,
    641792                    enigmaConfig.Ring3, enigmaConfig.Ring2, enigmaConfig.Ring1,
    642                     enigmaConfig.InitialRotorPos, _pluginFacade.pB2String(enigmaConfig.PlugBoard));
     793                    enigmaConfig.InitialRotorPos, _pluginFacade.pB2String(enigmaConfig.PlugBoard));*/
    643794                //_pluginFacade.LogMessage(msg, NotificationLevel.Info);
    644795
    645796                // no plug could lead to a better result, hence abort plug search.
    646                 if (!plugFound || _stopped)
     797                if (!plugFound || _stoppedOrFinished)
    647798                    break;
    648799            }
     
    791942                }
    792943
    793                 if (_stopped)
     944                if (_stoppedOrFinished)
    794945                    break;
    795946            }
     
    813964                }
    814965
    815                 if (_stopped)
     966                if (_stoppedOrFinished)
    816967                    break;
    817968            }
     
    8911042            message.AppendLine("=====================================");
    8921043
    893             foreach (analysisConfigSettings cfg in analysisCandidates)
     1044            foreach (analysisConfigSettings cfg in _analysisCandidates)
    8941045            {
    8951046                message.AppendFormat("{0} | {1},{2},{3} | {4},{5},{6} | {7} | {8}" + Environment.NewLine,
     
    9081059            }
    9091060            //pluginFacade.BestKey = message.ToString();
    910             _pluginFacade.SetBestKey(currentBestKey.ToString());
     1061            //_pluginFacade.SetBestKey(currentBestKey.ToString());
    9111062            //pluginFacade.LogMessage(message.ToString(), NotificationLevel.Info);
    9121063        }
     
    9211072        #region Public events
    9221073
    923         public event EventHandler<IntermediateResultEventArgs> OnIntermediateResult;
     1074        //public event EventHandler<IntermediateResultEventArgs> OnIntermediateResult;
    9241075
    9251076        #endregion
    9261077
    9271078        #region Public methods
    928 
    9291079
    9301080        /// <summary>
     
    9541104
    9551105            // some initialisation
    956             analysisCandidates.Clear();
    957             _stopped = false;
    958 
    959             keys = 0;
    960             lasttime = DateTime.Now;
     1106            _analysisCandidates.Clear();
     1107            _stoppedOrFinished = false;
     1108
     1109            _keys = 0;
     1110            _lasttime = DateTime.Now;
    9611111
    9621112            AnalyzeRun(preformatedText);
     
    9681118
    9691119            // decrypt all
    970             return analysisCandidates.Select(cfg => encrypt(cfg, preformatedText, cfg.PlugBoard));
     1120            return _analysisCandidates.Select(cfg => encrypt(cfg, preformatedText, cfg.PlugBoard));
    9711121        }
    9721122
     
    9771127                _pluginFacade.LogMessage("ANALYSIS: ====> Stage 1 - Searching used rotors and key <====", NotificationLevel.Info);
    9781128               
    979                 rotorPos1 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[0]);
    980                 rotorPos2 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[1]);
    981                 rotorPos3 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[2]);
     1129                _rotorPos1 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[0]);
     1130                _rotorPos2 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[1]);
     1131                _rotorPos3 = _settings.Alphabet.IndexOf(_settings.InitialRotorPos[2]);
    9821132
    9831133                analyzeRotors(preformatedText);
     
    10091159                    settingsConfig.InitialRotorPos = _settings.InitialRotorPos;
    10101160
    1011                     analysisCandidates.Add(settingsConfig);
     1161                    _analysisCandidates.Add(settingsConfig);
    10121162                }
    10131163            }
     
    10191169            //analysisCandidates[analysisCandidates.Count - 1].Key = "BKF";
    10201170
    1021             printBestCandidates();
    1022 
    1023             if (_stopped)
     1171            //printBestCandidates();
     1172
     1173            if (_stoppedOrFinished)
    10241174                return;
    10251175
     
    10311181                _pluginFacade.LogMessage("ANALYSIS: ====> Stage 2 - Searching ring positions <====", NotificationLevel.Info);
    10321182
    1033                 for (int j = analysisCandidates.Count - 1; j >= 0 && !_stopped; j--)
    1034                 {
    1035                     analysisCandidates[j].PlugBoard = _settings.Alphabet; // empty plugs
    1036                     analyzeRings(analysisCandidates[j], preformatedText);
    1037                 }
    1038 
    1039                 analysisCandidates.Sort();
     1183                for (int j = _analysisCandidates.Count - 1; j >= 0 && !_stoppedOrFinished; j--)
     1184                {
     1185                    _analysisCandidates[j].PlugBoard = _settings.Alphabet; // empty plugs
     1186                    analyzeRings(_analysisCandidates[j], preformatedText);
     1187                }
     1188
     1189                _analysisCandidates.Sort();
    10401190            }
    10411191            else
     
    10431193                _pluginFacade.LogMessage("ANALYSIS: ====> Skipping stage 2 - Using provided ring settings <====", NotificationLevel.Info);
    10441194
    1045                 for (int j = analysisCandidates.Count - 1; j >= 0 && !_stopped; j--)
    1046                 {
    1047                     analysisCandidates[j].PlugBoard = _settings.Alphabet; // empty plugs
    1048                     analysisCandidates[j].Ring1 = _settings.Ring1;
    1049                     analysisCandidates[j].Ring2 = _settings.Ring2;
    1050                     analysisCandidates[j].Ring3 = _settings.Ring3;
    1051                 }
    1052             }
    1053 
    1054             printBestCandidates();
    1055 
    1056             if (_stopped)
     1195                for (int j = _analysisCandidates.Count - 1; j >= 0 && !_stoppedOrFinished; j--)
     1196                {
     1197                    _analysisCandidates[j].PlugBoard = _settings.Alphabet; // empty plugs
     1198                    _analysisCandidates[j].Ring1 = _settings.Ring1;
     1199                    _analysisCandidates[j].Ring2 = _settings.Ring2;
     1200                    _analysisCandidates[j].Ring3 = _settings.Ring3;
     1201                }
     1202            }
     1203
     1204            //printBestCandidates();
     1205
     1206            if (_stoppedOrFinished)
    10571207                return;
    10581208
     
    10611211                _pluginFacade.LogMessage("ANALYSIS: ====> Stage 3 - Searching used plugs <====", NotificationLevel.Info);
    10621212
    1063                 for (int j = analysisCandidates.Count - 1; j >= 0 && !_stopped; j--)
    1064                 {
    1065                     string result = analyzePlugs(analysisCandidates[j], _settings.MaxSearchedPlugs, preformatedText);
     1213                for (int j = _analysisCandidates.Count - 1; j >= 0 && !_stoppedOrFinished; j--)
     1214                {
     1215                    string result = analyzePlugs(_analysisCandidates[j], _settings.MaxSearchedPlugs, preformatedText);
    10661216
    10671217                    // fire the event, so someting becomes visible..
    1068                     if (OnIntermediateResult != null)
     1218                    /*if (OnIntermediateResult != null)
    10691219                    {
    10701220                        OnIntermediateResult(this, new IntermediateResultEventArgs() { Result = result });
    1071                     }
    1072                 }
    1073 
    1074                 analysisCandidates.Sort();
     1221                    }*/
     1222                }
     1223
     1224                _analysisCandidates.Sort();
    10751225            }
    10761226            else
     
    10781228                _pluginFacade.LogMessage("ANALYSIS: ====> Skipping stage 3 - Using provided plugboard <====", NotificationLevel.Info);
    10791229
    1080                 for (int j = analysisCandidates.Count - 1; j >= 0 && !_stopped; j--)
    1081                 {
    1082                     analysisCandidates[j].PlugBoard = _settings.PlugBoard;
    1083                 }
    1084             }
    1085 
    1086             printBestCandidates();
     1230                for (int j = _analysisCandidates.Count - 1; j >= 0 && !_stoppedOrFinished; j--)
     1231                {
     1232                    _analysisCandidates[j].PlugBoard = _settings.PlugBoard;
     1233                }
     1234            }
     1235
     1236            //printBestCandidates();
    10871237        }
    10881238
     
    10921242        public void StopAnalysis()
    10931243        {
    1094             _stopped = true;
    1095         }
     1244            _stoppedOrFinished = true;
     1245        }
     1246       
     1247        /// <summary>
     1248        /// Updates the keys per second (to use once after the analysis).
     1249        /// </summary>
     1250        public void FinalUiUpdate()
     1251        {
     1252            var keysDispatcher2 = _keys;
     1253            var lasttimeDispatcher2 = _lasttime;
     1254            _pluginFacade.Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
     1255            {
     1256                try
     1257                {
     1258                    _presentation.currentSpeed.Content = string.Format("{0:0,0}", Math.Round(keysDispatcher2 * 1000 / (DateTime.Now - lasttimeDispatcher2).TotalMilliseconds, 0));
     1259                }
     1260                // ReSharper disable once EmptyGeneralCatchClause
     1261                catch (Exception e)
     1262                {
     1263                    //wtf?
     1264                    Console.WriteLine("e2: " + e);
     1265                }
     1266            }, null);
     1267        }
     1268       
    10961269
    10971270        /// <summary>
     
    11151288
    11161289            // now calculate the index of coincidences
    1117             for (int i = 0; i < statistics.Length && !_stopped; i++)
     1290            for (int i = 0; i < statistics.Length && !_stoppedOrFinished; i++)
    11181291            {
    11191292                cipherTextLength += statistics[i];
     
    11491322
    11501323    }
     1324
     1325    public static class SimilarityExtensions
     1326    {
     1327        /// <summary>
     1328        /// Returns the number of steps required to transform the source string
     1329        /// into the target string.
     1330        /// </summary>
     1331        public static int ComputeLevenshteinDistance(this string source, string target)
     1332        {
     1333            if (string.IsNullOrEmpty(source))
     1334                return string.IsNullOrEmpty(target) ? 0 : target.Length;
     1335
     1336            if (string.IsNullOrEmpty(target))
     1337                return string.IsNullOrEmpty(source) ? 0 : source.Length;
     1338
     1339            int sourceLength = source.Length;
     1340            int targetLength = target.Length;
     1341
     1342            int[,] distance = new int[sourceLength + 1, targetLength + 1];
     1343
     1344            // Step 1
     1345            for (int i = 0; i <= sourceLength; distance[i, 0] = i++) ;
     1346            for (int j = 0; j <= targetLength; distance[0, j] = j++) ;
     1347
     1348            for (int i = 1; i <= sourceLength; i++)
     1349            {
     1350                for (int j = 1; j <= targetLength; j++)
     1351                {
     1352                    // Step 2
     1353                    int cost = (target[j - 1] == source[i - 1]) ? 0 : 1;
     1354
     1355                    // Step 3
     1356                    distance[i, j] = Math.Min(
     1357                                        Math.Min(distance[i - 1, j] + 1, distance[i, j - 1] + 1),
     1358                                        distance[i - 1, j - 1] + cost);
     1359                }
     1360            }
     1361
     1362            return distance[sourceLength, targetLength];
     1363        }
     1364
     1365        /// <summary>
     1366        /// Calculate percentage similarity of two strings
     1367        /// <param name="source">Source String to Compare with</param>
     1368        /// <param name="target">Targeted String to Compare</param>
     1369        /// <returns>Return Similarity between two strings from 0 to 1.0</returns>
     1370        /// </summary>
     1371        public static double CalculateSimilarity(this string source, string target)
     1372        {
     1373            if (string.IsNullOrEmpty(source))
     1374                return string.IsNullOrEmpty(target) ? 1 : 0;
     1375
     1376            if (string.IsNullOrEmpty(target))
     1377                return string.IsNullOrEmpty(source) ? 1 : 0;
     1378
     1379            double stepsToSame = ComputeLevenshteinDistance(source, target);
     1380            return (1.0 - (stepsToSame / (double)Math.Max(source.Length, target.Length)));
     1381        }
     1382    }
    11511383}
  • trunk/CrypPlugins/EnigmaBreaker/EnigmaBreaker.cs

    r7240 r7247  
    7676        private DateTime _startTime;
    7777        private DateTime _endTime;
    78         public Boolean _isrunning;
    79         private Boolean _newCiphertext = false;
    80         private Boolean _newKey = false;
     78        public bool _isrunning;
     79        private bool _newCiphertext = false;
     80        private bool _newKey = false;
    8181
    8282        private bool _running = false;
    8383        private bool _stopped = false;
     84
     85        // EVALUATION!
     86        private static int threads = 1;
     87        private static int currentThread = 0;
     88        private int _improvements = 0;
     89
     90        private string _plaintextInput;
     91        private double _percentageInput;
     92
     93        private bool _newPlaintext = false;
     94        private bool _newPercentage = false;
     95
     96        private TimeSpan _runtime = new TimeSpan();
     97        private bool _finished = false;
     98        private int _totalNumberOfRestarts;
     99        private int _totalNumberOfDecryptions;
     100        private int[] _numberOfRestarts;
     101        private int[] _numberOfDecryptions;
    84102
    85103        #endregion
     
    269287        /// <param name="sender"></param>
    270288        /// <param name="e"></param>
    271         private void analyzer_OnIntermediateResult(object sender, IntermediateResultEventArgs e)
     289        /*private void analyzer_OnIntermediateResult(object sender, IntermediateResultEventArgs e)
    272290        {
    273291            // Got an intermidate results from the analyzer, hence display it
    274292            _bestPlaintext = postFormatOutput(e.Result);
    275293            //OnPropertyChanged("BestPlaintext");
    276         }
     294        }*/
    277295
    278296        #endregion
     
    342360            this._core = new EnigmaCore(this);
    343361            this._analyzer = new EnigmaAnalyzer(this);
    344             this._analyzer.OnIntermediateResult += new EventHandler<IntermediateResultEventArgs>(analyzer_OnIntermediateResult);
     362            //this._analyzer.OnIntermediateResult += new EventHandler<IntermediateResultEventArgs>(analyzer_OnIntermediateResult);
    345363            this._statistics = new Dictionary<int, IDictionary<string, double[]>>();
    346364            _presentation.UpdateOutputFromUserChoice += UpdateOutputFromUserChoice;
     
    411429                    OnPropertyChanged("Ciphertext");
    412430                }
     431            }
     432        }
     433
     434        // EVALUATION!
     435        [PropertyInfo(Direction.InputData, "PlaintextInputCaption", "PlaintextInputTooltip", false)]
     436        public string CorrectPlaintextInput
     437        {
     438            get { return this._plaintextInput; }
     439            set
     440            {
     441                if (!String.IsNullOrEmpty(value) && value != this._plaintextInput)
     442                {
     443                    this._plaintextInput = value;
     444                    OnPropertyChanged("CorrectPlaintextInput");
     445                    this._newPlaintext = true;
     446                }
     447            }
     448        }
     449
     450        // EVALUATION!
     451        [PropertyInfo(Direction.InputData, "DecryptionPercentageCaption", "DecryptionPercentageTooltip", false)]
     452        public double MinimalCorrectPercentage
     453        {
     454            get { return this._percentageInput; }
     455            set
     456            {
     457                this._percentageInput = value;
     458                this._newPercentage = true;
     459                OnPropertyChanged("MinimalCorrectPercentage");
    413460            }
    414461        }
     
    450497        }
    451498
     499        // EVALUATION!
     500        [PropertyInfo(Direction.OutputData, "EvaluationOutputCaption", "EvaluationOutputTooltip", true)]
     501        public EvaluationContainer EvaluationOutput
     502        {
     503            get
     504            {
     505                var elapsedtime = DateTime.Now.Subtract(_startTime);
     506                _runtime = new TimeSpan(elapsedtime.Days, elapsedtime.Hours, elapsedtime.Minutes, elapsedtime.Seconds, elapsedtime.Milliseconds);
     507                var ID = _ciphertextInput.GetHashCode();
     508
     509                return new EvaluationContainer(ID, _runtime, _totalNumberOfDecryptions, _totalNumberOfRestarts);
     510            }
     511        }
     512
    452513
    453514        #endregion
     
    455516        #region Public methods
    456517
     518        public bool Finished
     519        {
     520            get { return this._finished; }
     521            set { this._finished = value; }
     522        }
     523
     524        public bool IncrementDecryptionsCountForThread(int thread)
     525        {
     526            if (_numberOfDecryptions.Length - 1 < thread)
     527                return false;
     528
     529            _numberOfDecryptions[thread]++;
     530
     531            return true;
     532        }
     533
     534        public bool IncrementRestartsCountForThread(int thread)
     535        {
     536            if (_numberOfRestarts.Length - 1 < thread)
     537                return false;
     538
     539            _numberOfRestarts[thread]++;
     540
     541            return true;
     542        }
     543
     544        /*
    457545        public void SetBestKey (string key)
    458546        {
    459547            this._bestKey = key;
    460         }
     548        }*/
    461549
    462550        public void PreExecution()
     
    493581            ShowProgress(0, 1);
    494582
    495             if (_ciphertextInput == null)
     583            if (!_newCiphertext)
    496584                return;
    497585
     
    506594            string preformatedText = preFormatInput(_ciphertextInput);
    507595
     596            // EVALUATION! if stopping is active, percentage and plaintext are necessary
     597            if (_settings.StopIfPercentReached &&
     598                    (!_newPercentage || !_newPlaintext))
     599            {
     600                // wait for new values
     601                return;
     602            }
     603
     604            // consume values
     605            _newCiphertext = false;
     606            _newPercentage = false;
     607            _newPlaintext = false;
     608
     609            // EVALUATION!
     610            if (_percentageInput <= 0 ||
     611                _percentageInput > 100)
     612            {
     613                _percentageInput = 95;
     614            }
     615            _runtime = new TimeSpan();
     616
     617            _totalNumberOfRestarts = 0;
     618            _totalNumberOfDecryptions = 0;
     619            _numberOfRestarts = new int[1 /*_settings.CoresUsed*/]; // prepared for multi threading
     620            _numberOfDecryptions = new int[1 /*_settings.CoresUsed*/];
     621            for (int t = 1 /*_settings.CoresUsed*/ - 1; t >= 0; t--)
     622            {
     623                _numberOfRestarts[t] = 0;
     624                _numberOfDecryptions[t] = 0;
     625            }
     626
    508627            UpdateDisplayStart();
    509628
     
    519638            UpdateDisplayEnd();
    520639
    521             // TODO: We update finally the keys/second of the ui
    522             /*var keysDispatcher2 = keys;
    523             var lasttimeDispatcher2 = lasttime;
    524             Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
    525             {
    526                 try
    527                 {
    528                     _presentation.currentSpeed.Content = string.Format("{0:0,0}", Math.Round(keysDispatcher2 * 1000 / (DateTime.Now - lasttimeDispatcher2).TotalMilliseconds, 0));
    529                 }
    530                 // ReSharper disable once EmptyGeneralCatchClause
    531                 catch (Exception e)
    532                 {
    533                     //wtf?
    534                     Console.WriteLine("e2: " + e);
    535                 }
    536             }, null);*/
     640            // We update finally the keys/second of the ui
     641            _analyzer.FinalUiUpdate();
     642
     643            // EVALUATION!
     644            for (var i = 0; i < threads; i++)
     645            {
     646                _totalNumberOfRestarts += _numberOfRestarts[i];
     647                _totalNumberOfDecryptions += _numberOfDecryptions[i];
     648            }
     649            // adding 1 for the last decryption
     650            _totalNumberOfDecryptions++;
    537651           
    538652            if (_presentation.BestList.Count > 0)
     
    540654                BestPlaintext = _presentation.BestList[0].Text;
    541655                BestKey = _presentation.BestList[0].Key;
     656
     657                // EVALUATION!
     658                _finished = false;
     659                OnPropertyChanged("EvaluationOutput");
    542660            }
    543661
    544662            // "fire" the outputs
    545             OnPropertyChanged("BestPlaintext");
    546             OnPropertyChanged("BestKey");
     663            //OnPropertyChanged("BestPlaintext");
     664            //OnPropertyChanged("BestKey");
    547665
    548666            ShowProgress(1, 1);
     
    551669        public void PostExecution()
    552670        {
    553             LogMessage("Enigma shutting down. Reverting key to inial value!", NotificationLevel.Info);
    554             if (_savedKey != null && _savedKey.Length > 0)
    555             {
    556                 _settings.InitialRotorPos = _savedKey; // re-set the key
    557             }
    558 
    559671            _running = false;
    560672            _isrunning = false;
     
    563675            _startTime = new DateTime();
    564676            _endTime = new DateTime();
     677            _bestKey = String.Empty;
     678            _bestPlaintext = String.Empty;
     679
     680            // EVALUATION! reset values
     681            _plaintextInput = String.Empty;
     682            _percentageInput = new Double();
     683            _runtime = new TimeSpan();
     684            _totalNumberOfRestarts = 0;
     685            _totalNumberOfDecryptions = 0;
     686            _improvements = 0;
     687            _finished = false;
    565688        }
    566689
     
    580703            //LogMessage("Dispose", NotificationLevel.Debug);
    581704        }
    582 
    583 
    584705
    585706        /// <summary>
  • trunk/CrypPlugins/EnigmaBreaker/EnigmaBreakerSettings.cs

    r7240 r7247  
    11/*
    2    Copyright 2008-2012, Arno Wacker, University of Kassel
     2   Copyright 2008-2017, Arno Wacker, University of Kassel
    33
    44   Licensed under the Apache License, Version 2.0 (the "License");
     
    7676
    7777        private StringBuilder plugBoard = new StringBuilder("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
     78
     79        // EVALUATION!
     80        private bool _stopIfPercentReached = false;
     81        private int _comparisonFrequency = 1;
    7882
    7983        #endregion
     
    12911295        #endregion
    12921296
     1297        #region Evaluation settings
     1298
     1299        // EVALUATION!
     1300        [TaskPane("Stop current analysis if percent reached", "Stop the current analysis in the cryptanalytic component if entered percentage reached", null, 7, false, ControlType.CheckBox)]
     1301        public bool StopIfPercentReached
     1302        {
     1303            get
     1304            {
     1305                return this._stopIfPercentReached;
     1306            }
     1307            set
     1308            {
     1309                this._stopIfPercentReached = value;
     1310                OnPropertyChanged("StopIfPercentReached");
     1311            }
     1312        }
     1313
     1314        // EVALUATION!
     1315        [TaskPane("ComparisonFrequencyCaption", "ComparisonFrequencyTooltip", null, 8, false, ControlType.NumericUpDown, ValidationType.RangeInteger, 1, 10000)]
     1316        public int ComparisonFrequency
     1317        {
     1318            get
     1319            {
     1320                return _comparisonFrequency;
     1321            }
     1322            set
     1323            {
     1324                if (value != _comparisonFrequency)
     1325                {
     1326                    _comparisonFrequency = value;
     1327                    OnPropertyChanged("ComparisonFrequency");
     1328                }
     1329            }
     1330        }
     1331
     1332        #endregion
     1333
    12931334        #endregion
    12941335
  • trunk/CrypPlugins/EnigmaBreaker/Properties/Resources.Designer.cs

    r7240 r7247  
    233233       
    234234        /// <summary>
    235         ///   Looks up a localized string similar to Analyze initial rotor pos.
    236         /// </summary>
    237         public static string AnalyzeKeyCaption {
     235        ///   Looks up a localized string similar to Analyze initial rotor positions.
     236        /// </summary>
     237        public static string AnalyzeInitialRotorPosCaption {
    238238            get {
    239239                return ResourceManager.GetString("AnalyzeInitialRotorPosCaption", resourceCulture);
     
    242242       
    243243        /// <summary>
    244         ///   Looks up a localized string similar to If checked, the analysis tries to detect the correct key. If unchecked, the value from &quot;Key&quot; is used..
    245         /// </summary>
    246         public static string AnalyzeKeyTooltip {
     244        ///   Looks up a localized string similar to If checked, the analysis tries to detect the correct key. If unchecked, the value from &quot;Initial rotor positions&quot; is used..
     245        /// </summary>
     246        public static string AnalyzeInitialRotorPosTooltip {
    247247            get {
    248248                return ResourceManager.GetString("AnalyzeInitialRotorPosTooltip", resourceCulture);
     
    449449       
    450450        /// <summary>
    451         ///   Looks up a localized string similar to Current analyzed keylength:.
     451        ///   Looks up a localized string similar to Currently analyzed part:.
    452452        /// </summary>
    453453        public static string CurrentlyAnalysedLabel {
     
    14121412       
    14131413        /// <summary>
    1414         ///   Looks up a localized string similar to EnigmaBreaker.
     1414        ///   Looks up a localized string similar to Enigma Breaker.
    14151415        /// </summary>
    14161416        public static string PluginCaption {
     
    14301430       
    14311431        /// <summary>
     1432        ///   Looks up a localized string similar to Plugs.
     1433        /// </summary>
     1434        public static string PlugsCaption {
     1435            get {
     1436                return ResourceManager.GetString("PlugsCaption", resourceCulture);
     1437            }
     1438        }
     1439       
     1440        /// <summary>
    14321441        ///   Looks up a localized string similar to Plug search method.
    14331442        /// </summary>
     
    16551664       
    16561665        /// <summary>
     1666        ///   Looks up a localized string similar to Rings.
     1667        /// </summary>
     1668        public static string RingsCaption {
     1669            get {
     1670                return ResourceManager.GetString("RingsCaption", resourceCulture);
     1671            }
     1672        }
     1673       
     1674        /// <summary>
    16571675        ///   Looks up a localized string similar to Ring settings.
    16581676        /// </summary>
     
    19882006       
    19892007        /// <summary>
     2008        ///   Looks up a localized string similar to Rotors.
     2009        /// </summary>
     2010        public static string RotorsCaption {
     2011            get {
     2012                return ResourceManager.GetString("RotorsCaption", resourceCulture);
     2013            }
     2014        }
     2015       
     2016        /// <summary>
    19902017        ///   Looks up a localized string similar to Rotor/Ring/Key search method.
    19912018        /// </summary>
     
    21642191            get {
    21652192                return ResourceManager.GetString("ValueHeader", resourceCulture);
    2166             }
    2167         }
    2168        
    2169         /// <summary>
    2170         ///   Looks up a localized string similar to Rotors.
    2171         /// </summary>
    2172         public static string RotorsCaption {
    2173             get {
    2174                 return ResourceManager.GetString("RotorsCaption", resourceCulture);
    2175             }
    2176         }
    2177        
    2178         /// <summary>
    2179         ///   Looks up a localized string similar to Rings.
    2180         /// </summary>
    2181         public static string RingsCaption {
    2182             get {
    2183                 return ResourceManager.GetString("RingsCaption", resourceCulture);
    2184             }
    2185         }
    2186        
    2187         /// <summary>
    2188         ///   Looks up a localized string similar to Value.
    2189         /// </summary>
    2190         public static string PlugsCaption {
    2191             get {
    2192                 return ResourceManager.GetString("PlugsCaption", resourceCulture);
    21932193            }
    21942194        }
  • trunk/CrypPlugins/EnigmaBreaker/Properties/Resources.de.resx

    r7240 r7247  
    125125  </data>
    126126  <data name="PluginCaption" xml:space="preserve">
    127     <value>EnigmaBreaker</value>
     127    <value>Enigma Breaker</value>
    128128  </data>
    129129  <data name="PluginTooltip" xml:space="preserve">
     
    760760    <value>Gamma -- seit 1. Juli 1943</value>
    761761  </data>
    762 
    763762  <data name="Copy_all" xml:space="preserve">
    764763    <value>Kopiere alle Zeilen.</value>
     
    803802    <value>Aktuell analysierter Teil:</value>
    804803  </data>
    805 
    806804  <data name="CiphertextCaption" xml:space="preserve">
    807805    <value>Geheimtext</value>
     
    836834wurde.</value>
    837835  </data>
    838 
    839836  <data name="RotorsCaption" xml:space="preserve">
    840837    <value>Rotoren</value>
  • trunk/CrypPlugins/EnigmaBreaker/Properties/Resources.resx

    r7240 r7247  
    125125  </data>
    126126  <data name="PluginCaption" xml:space="preserve">
    127     <value>EnigmaBreaker</value>
     127    <value>Enigma Breaker</value>
    128128  </data>
    129129  <data name="PluginTooltip" xml:space="preserve">
     
    754754    <value>Gamma -- since 1st July 1943</value>
    755755  </data>
    756 
    757756  <data name="Copy_all" xml:space="preserve">
    758757    <value>Copy all lines</value>
     
    797796    <value>Currently analyzed part:</value>
    798797  </data>
    799 
    800798  <data name="CiphertextCaption" xml:space="preserve">
    801799    <value>Ciphertext</value>
     
    822820    <value>The best plaintext which was found during the analysis.</value>
    823821  </data>
    824 
    825822  <data name="RotorsCaption" xml:space="preserve">
    826823    <value>Rotors</value>
Note: See TracChangeset for help on using the changeset viewer.