Changeset 354


Ignore:
Timestamp:
Jun 15, 2009, 11:42:54 PM (12 years ago)
Author:
Arno Wacker
Message:

Enigma:

  • Removed all old/uncommented code (cleanup)
  • Minor modification on Enigma-Analyzer-Sample-02.cte
Location:
trunk
Files:
2 edited

Legend:

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

    r353 r354  
    233233        #region Private variables
    234234
    235         private bool stop = false;
    236 
    237235        private EnigmaSettings settings;
    238236        private EnigmaCore core;
     
    241239        private string outputString;
    242240        private string savedKey;
    243        
    244         //private class analysisConfigSettings :IComparable<analysisConfigSettings>
    245         //{
    246         //    public int Rotor1;
    247         //    public int Rotor2;
    248         //    public int Rotor3;
    249         //    public int Ring1;
    250         //    public int Ring2;
    251         //    public int Ring3;
    252         //    public string Key;
    253         //    public string PlugBoard = "-- no plugs --";
    254         //    public double IC;
    255 
    256         //    #region IComparable<analysisConfigSettings> Member
    257 
    258         //    public int CompareTo(analysisConfigSettings other)
    259         //    {
    260         //        return this.IC.CompareTo(other.IC);
    261         //    }
    262 
    263         //    #endregion
    264         //}
    265 
    266         //private List<analysisConfigSettings> analysisCandidates = new List<analysisConfigSettings>();
    267         //private const int maxAnalysisEntries = 10;
    268        
    269241       
    270242        #endregion
     
    345317        #endregion
    346318
    347         #region Analyzer
     319        #region Analyzer event handler
    348320
    349321        /// <summary>
     
    358330            OnPropertyChanged("OutputString");
    359331        }
    360 
    361 
    362 
    363         //private void printBestCandidates()
    364         //{
    365         //    StringBuilder message = new StringBuilder("  -- Analysis results --" + Environment.NewLine);
    366         //    message.AppendLine("=====================================");
    367 
    368         //    foreach (analysisConfigSettings cfg in analysisCandidates)
    369         //    {
    370         //        message.AppendFormat("{0} | {1},{2},{3} | {4},{5},{6} | {7} | {8}" + Environment.NewLine,
    371         //            cfg.IC.ToString(),
    372         //            (rotorEnum)cfg.Rotor3, (rotorEnum)cfg.Rotor2, (rotorEnum)cfg.Rotor1,
    373         //            cfg.Ring3.ToString("00"), cfg.Ring2.ToString("00"), cfg.Ring1.ToString("00"),
    374         //            cfg.Key, pB2String(cfg.PlugBoard));
    375         //    }
    376 
    377         //    EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message.ToString(), this, NotificationLevel.Info));
    378         //}
    379 
    380         //private string analyze(int rotor1Pos, int rotor2Pos, int rotor3Pos, string text)
    381         //{
    382         //    string result = core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos,0,text);
    383         //    double newIC = calculateIC(result);
    384 
    385         //    if (analysisCandidates.Count >= maxAnalysisEntries)
    386         //    {
    387         //        // List is full, check if we need to remove one
    388         //        if (newIC > analysisCandidates[0].IC)
    389         //        {
    390         //            double currentMax = analysisCandidates[analysisCandidates.Count - 1].IC;
    391 
    392         //            analysisConfigSettings csetting = new analysisConfigSettings();
    393         //            csetting.IC = newIC;
    394         //            csetting.Rotor1 = core.Rotor1;
    395         //            csetting.Rotor2 = core.Rotor2;
    396         //            csetting.Rotor3 = core.Rotor3;
    397         //            csetting.Ring1 = core.Ring1;
    398         //            csetting.Ring2 = core.Ring2;
    399         //            csetting.Ring3 = core.Ring3;
    400         //            csetting.PlugBoard = core.Plugboard;
    401         //            csetting.Key = settings.Alphabet[rotor3Pos].ToString() + settings.Alphabet[rotor2Pos].ToString() + settings.Alphabet[rotor1Pos].ToString();
    402 
    403         //            analysisCandidates.Add(csetting);
    404         //            analysisCandidates.Sort();
    405 
    406         //            // remove the smallest one
    407         //            analysisCandidates.RemoveAt(0);
    408 
    409 
    410         //            if (newIC > currentMax)
    411         //            {
    412         //                // new best option
    413         //                string status = String.Format("ANALYSIS: ==> Found better rotor settings: {0},{1},{2}; {3},{4},{5}; Key: {6}; I.C.={7} <==",
    414         //                (rotorEnum)csetting.Rotor3, (rotorEnum)csetting.Rotor2, (rotorEnum)csetting.Rotor1,
    415         //                csetting.Ring3.ToString("00"), csetting.Ring2.ToString("00"), csetting.Ring1.ToString("00"),
    416         //                csetting.Key, newIC.ToString());
    417         //                EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(status, this, NotificationLevel.Info));
    418 
    419         //                printBestCandidates();
    420 
    421         //                outputString = result;
    422         //                OnPropertyChanged("OutputString");
    423         //            }
    424 
    425                    
    426         //        }
    427         //    }
    428         //    else
    429         //    {
    430         //        //there is room left, hence add the element
    431 
    432         //        analysisConfigSettings csetting = new analysisConfigSettings();
    433         //        csetting.IC = newIC;
    434         //        csetting.Rotor1 = core.Rotor1;
    435         //        csetting.Rotor2 = core.Rotor2;
    436         //        csetting.Rotor3 = core.Rotor3;
    437         //        csetting.Ring1 = core.Ring1;
    438         //        csetting.Ring2 = core.Ring2;
    439         //        csetting.Ring3 = core.Ring3;
    440         //        csetting.PlugBoard = core.Plugboard;
    441         //        csetting.Key = settings.Alphabet[rotor3Pos].ToString() + settings.Alphabet[rotor2Pos].ToString() + settings.Alphabet[rotor1Pos].ToString();
    442 
    443         //        analysisCandidates.Add(csetting);
    444         //        analysisCandidates.Sort();
    445 
    446         //        if (analysisCandidates.Count == maxAnalysisEntries)
    447         //        {
    448         //            printBestCandidates();
    449 
    450         //            // current best option
    451         //            analysisConfigSettings bestOption = analysisCandidates[analysisCandidates.Count - 1];
    452 
    453         //            string status = String.Format("ANALYSIS: Best candidates is filled. Best option so far: {0},{1},{2}; Key: {3}; I.C.={4}",
    454         //            (rotorEnum)bestOption.Rotor3, (rotorEnum)bestOption.Rotor2, (rotorEnum)bestOption.Rotor1, bestOption.Key, bestOption.IC.ToString());
    455         //            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(status, this, NotificationLevel.Debug));
    456 
    457         //            // fire the event, so someting becomes visible..
    458         //            outputString = result;
    459         //            OnPropertyChanged("OutputString");
    460         //        }
    461 
    462         //    }
    463 
    464         //    return result;
    465         //}
    466 
    467         //private double calculateIC(string input)
    468         //{
    469         //    int[] statistics = new int[settings.Alphabet.Length];
    470         //    long cipherTextLength = 0; //input.Length; //n
    471         //    long countDoubleCharacters = 0;
    472 
    473         //    // first count the frequency of (single) letters
    474         //    foreach (char c in input)
    475         //    {
    476         //        int i = settings.Alphabet.IndexOf(char.ToUpper(c));
    477         //        if (i >= 0) statistics[i]++;
    478         //    }
    479 
    480 
    481         //    // now calculate the index of coincidences
    482         //    for (int i = 0; i < statistics.Length; i++)
    483         //    {
    484         //        cipherTextLength += statistics[i];
    485         //        countDoubleCharacters += (statistics[i] * (statistics[i] - 1));
    486         //    }
    487 
    488         //    return((double)countDoubleCharacters / (double)(cipherTextLength * (cipherTextLength - 1)));
    489         //}
    490 
    491         //private void runAnalysis(string inputText)
    492         //{
    493         //    LogMessage("=========> ANALYSIS OF ENIGMA MESSAGE STARTED <=========", NotificationLevel.Info);
    494 
    495 
    496         //    // some initialisation
    497         //    analysisCandidates.Clear();
    498 
    499 
    500         //    //prepare for analysis
    501         //    LogMessage("ANALYSIS: Preformatting text...", NotificationLevel.Debug);
    502         //    string preformatedText = preFormatInput(inputText);
    503 
    504         //    if (settings.AnalyzeRotors)
    505         //    {
    506         //        LogMessage("ANALYSIS: ====> Stage 1 - Searching used rotors <====", NotificationLevel.Info);
    507         //        analyzeRotors(preformatedText);
    508         //    }
    509         //    else
    510         //    {
    511         //        LogMessage("ANALYSIS: ====> Skipping stage 1 - Using rotors  from settings <====", NotificationLevel.Info);
    512         //        analysisConfigSettings settingsConfig = new analysisConfigSettings();
    513         //        settingsConfig.Rotor1 = settings.Rotor1;
    514         //        settingsConfig.Rotor2 = settings.Rotor2;
    515         //        settingsConfig.Rotor3 = settings.Rotor3;
    516         //        settingsConfig.Ring1 = settings.AnalyzeRings ? 1 : settings.Ring1;
    517         //        settingsConfig.Ring2 = settings.AnalyzeRings ? 1 : settings.Ring2;
    518         //        settingsConfig.Ring3 = settings.AnalyzeRings ? 1 : settings.Ring3;
    519         //        settingsConfig.Key = settings.Key;
    520 
    521         //        analysisCandidates.Add(settingsConfig);
    522         //    }
    523            
    524         //    // just for debugging
    525         //    //analysisCandidates[analysisCandidates.Count-1].Rotor1 = 2;
    526         //    //analysisCandidates[analysisCandidates.Count - 1].Rotor2 = 0;
    527         //    //analysisCandidates[analysisCandidates.Count - 1].Rotor3 = 1;
    528         //    //analysisCandidates[analysisCandidates.Count - 1].Key = "BKF";
    529 
    530         //    printBestCandidates();
    531 
    532         //    // put the core in quiet mode, since now many internal changes occur
    533         //    core.VerboseLevel = VerboseLevels.Quiet;
    534 
    535         //    if (settings.AnalyzeRings)
    536         //    {
    537         //        LogMessage("ANALYSIS: ====> Stage 2 - Searching ring positions <====", NotificationLevel.Info);
    538 
    539         //        for (int j = analysisCandidates.Count - 1; j >= 0; j--)
    540         //        {
    541         //            analysisCandidates[j].PlugBoard = settings.Alphabet; // empty plugs
    542         //            analyzeRings(analysisCandidates[j], preformatedText);
    543         //        }
    544 
    545         //        analysisCandidates.Sort();
    546         //    }
    547         //    else
    548         //    {
    549         //        LogMessage("ANALYSIS: ====> Skipping stage 2 - Using provided ring settings <====", NotificationLevel.Info);
    550 
    551         //        for (int j = analysisCandidates.Count - 1; j >= 0; j--)
    552         //        {
    553         //            analysisCandidates[j].PlugBoard = settings.Alphabet; // empty plugs
    554         //            analysisCandidates[j].Ring1 = settings.Ring1;
    555         //            analysisCandidates[j].Ring2 = settings.Ring2;
    556         //            analysisCandidates[j].Ring3 = settings.Ring3;
    557         //        }
    558         //    }
    559 
    560         //    printBestCandidates();
    561 
    562 
    563         //    if (settings.AnalyzePlugs)
    564         //    {
    565         //        LogMessage("ANALYSIS: ====> Stage 3 - Searching used plugs <====", NotificationLevel.Info);
    566 
    567         //        for (int j = analysisCandidates.Count - 1; j >= 0; j--)
    568         //        {
    569         //            analyzePlugs(analysisCandidates[j], settings.MaxSearchedPlugs, preformatedText);
    570         //        }
    571 
    572         //        analysisCandidates.Sort();
    573         //    }
    574         //    else
    575         //    {
    576         //        LogMessage("ANALYSIS: ====> Skipping stage 3 - Using provided plugboard <====", NotificationLevel.Info);
    577 
    578         //        for (int j = analysisCandidates.Count - 1; j >= 0; j--)
    579         //        {
    580         //            analysisCandidates[j].PlugBoard = settings.PlugBoard;
    581         //        }
    582         //    }
    583 
    584         //    printBestCandidates();
    585 
    586            
    587         //    LogMessage("=========> ANALYSIS OF ENIGMA MESSAGE DONE <=========", NotificationLevel.Info);
    588 
    589         //    // switch back to verbose core
    590         //    core.VerboseLevel = VerboseLevels.VeryVerbose;
    591 
    592         //    // decrypt with best option
    593         //    analysisConfigSettings bestConfig = analysisCandidates[analysisCandidates.Count - 1];
    594 
    595         //    core.setInternalConfig(bestConfig.Rotor1, bestConfig.Rotor2, bestConfig.Rotor3, 0, settings.Reflector, bestConfig.Ring1, bestConfig.Ring2, bestConfig.Ring3, 1, bestConfig.PlugBoard);
    596         //    int r1p = settings.Alphabet.IndexOf(bestConfig.Key[2]);
    597         //    int r2p = settings.Alphabet.IndexOf(bestConfig.Key[1]);
    598         //    int r3p = settings.Alphabet.IndexOf(bestConfig.Key[0]);
    599         //    outputString = postFormatOutput(core.Encrypt(r1p, r2p, r3p, 0, preformatedText));
    600         //    OnPropertyChanged("OutputString");
    601 
    602         //}
    603 
    604         //private void analyzeRotors(string text)
    605         //{
    606         //    // Start the stopwatch
    607         //    Stopwatch sw = Stopwatch.StartNew();
    608         //    int trials = 0;
    609 
    610         //    for (int i = 0; i < 8; i++)
    611         //    {
    612         //        //Rotor 3 (slowest)
    613         //        if (!includeRotor(i)) continue;
    614         //        settings.Rotor3 = i;
    615         //        for (int j = 0; j < 8; j++)
    616         //        {
    617         //            // Rotor 2 (middle)
    618         //            if (!includeRotor(j) || j==i) continue;
    619         //            settings.Rotor2 = j;
    620 
    621         //            for (int k = 0; k < 8; k++)
    622         //            {
    623         //                // Rotor 1 (fastest)
    624         //                if (!includeRotor(k) || k == i || k == j) continue;
    625         //                settings.Rotor1 = k;
    626 
    627         //                //set the internal Config to the new rotors
    628         //                core.setInternalConfig(k, j, i, 0, settings.Reflector,
    629         //                    settings.AnalyzeRings?1: settings.Ring1,
    630         //                    settings.AnalyzeRings ? 1 : settings.Ring2,
    631         //                    settings.AnalyzeRings ? 1 : settings.Ring3,
    632         //                    settings.Ring4,
    633         //                    settings.AnalyzePlugs ? settings.Alphabet: settings.PlugBoard);
    634 
    635         //                analyzeKey(text);
    636         //                trials++;
    637 
    638         //                EventsHelper.ProgressChanged(OnPluginProgressChanged, this,
    639         //                        new PluginProgressEventArgs(i * Math.Pow(8, 2) + j * 8 + k, Math.Pow(8, 3)));
    640 
    641         //                if (stop) break;
    642         //            } // Rotor 1
    643         //            if (stop) break;
    644         //        } // Rotor 2
    645         //        if (stop) break;
    646         //    } // Rotor 3
    647 
    648         //    // Stop the stopwatch
    649         //    sw.Stop();
    650 
    651         //    string msg = String.Format("Processed {0} rotor permutations in {1}!",
    652         //        trials, sw.Elapsed.ToString());
    653         //    LogMessage(msg, NotificationLevel.Info);
    654         //}
    655 
    656         //private bool includeRotor(int i)
    657         //{
    658         //    switch (i)
    659         //    {
    660         //        case 0: return settings.AnalysisUseRotorI;
    661         //        case 1: return settings.AnalysisUseRotorII;
    662         //        case 2: return settings.AnalysisUseRotorIII;
    663         //        case 3: return settings.AnalysisUseRotorIV;
    664         //        case 4: return settings.AnalysisUseRotorV;
    665         //        case 5: return settings.AnalysisUseRotorVI;
    666         //        case 6: return settings.AnalysisUseRotorVII;
    667         //        case 7: return settings.AnalysisUseRotorVIII;
    668         //    }
    669         //    return false;
    670         //}
    671 
    672         //private void analyzeKey(string text)
    673         //{
    674         //    /////////////////////////////////////////
    675         //    // now run through all rotor positions..
    676 
    677         //    // Start the stopwatch
    678         //    Stopwatch sw = Stopwatch.StartNew();
    679         //    int trials = 0;
    680 
    681         //    // Rotor 1 positions (fastest)
    682         //    for (int l = 0; l < 26; l++)
    683         //    {
    684         //        for (int m = 0; m < 26; m++)
    685         //        {
    686         //            for (int n = 0; n < 26; n++)
    687         //            {
    688         //                analyze(l, m, n, text);
    689         //                trials++;
    690         //                if (stop) break;
    691         //            }
    692         //            if (stop) break;
    693         //        }
    694         //        if (stop) break;
    695         //    } // Rotor1 positions
    696 
    697         //    // Stop the stopwatch
    698         //    sw.Stop();
    699 
    700         //    string msg = String.Format("Processed {0} rotor positions for {1},{2},{3} in {4}!",
    701         //        trials, (rotorEnum)core.Rotor3, (rotorEnum)core.Rotor2, (rotorEnum)core.Rotor1, sw.Elapsed.ToString());
    702         //    LogMessage(msg, NotificationLevel.Info);
    703         //}
    704 
    705         //private void analyzeRings(analysisConfigSettings enigmaConfig, string text)
    706         //{
    707 
    708         //    // get the current rotor positions
    709         //    int r1pos = settings.Alphabet.IndexOf(enigmaConfig.Key[2]);
    710         //    int r2pos = settings.Alphabet.IndexOf(enigmaConfig.Key[1]);
    711         //    int r3pos = settings.Alphabet.IndexOf(enigmaConfig.Key[0]);
    712 
    713         //    if (settings.AnalyzeKey)
    714         //    {
    715         //        // turn fast rotor
    716         //        for (int i = 1; i <= settings.Alphabet.Length; i++)
    717         //        {
    718         //            core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, i, 1, 1, 1, enigmaConfig.PlugBoard);
    719 
    720 
    721         //            int rotatedR1Pos;
    722         //            if (settings.AnalyzeKey)
    723         //                // rotate the fast rotor with the ring
    724         //                rotatedR1Pos = (r1pos + (i - 1)) % settings.Alphabet.Length;
    725         //            else
    726         //                rotatedR1Pos = r1pos;
    727 
    728 
    729         //            string result = core.Encrypt(rotatedR1Pos, r2pos, r3pos, 0, text);
    730 
    731         //            double newIC = calculateIC(result);
    732 
    733         //            if (newIC > enigmaConfig.IC)
    734         //            {
    735         //                //better value, hence update the data
    736         //                enigmaConfig.IC = newIC;
    737         //                enigmaConfig.Ring1 = i;
    738         //                enigmaConfig.Key = settings.Alphabet[r3pos].ToString() + settings.Alphabet[r2pos].ToString() + settings.Alphabet[rotatedR1Pos].ToString();
    739         //            }
    740 
    741         //        }
    742 
    743         //        // update the current rotor positions (only rotor 1 might have changed)
    744         //        r1pos = settings.Alphabet.IndexOf(enigmaConfig.Key[2]);
    745 
    746         //        // turn middle rotor
    747         //        for (int i = 1; i <= settings.Alphabet.Length; i++)
    748         //        {
    749         //            core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, enigmaConfig.Ring1, i, 1, 1, enigmaConfig.PlugBoard);
    750 
    751         //            int rotatedR2Pos;
    752         //            if (settings.AnalyzeKey)
    753         //                // rotate the middle rotor with the ring
    754         //                rotatedR2Pos = (r2pos + (i - 1)) % settings.Alphabet.Length;
    755         //            else
    756         //                rotatedR2Pos = r2pos;
    757 
    758         //            string result = core.Encrypt(r1pos, rotatedR2Pos, r3pos, 0, text);
    759 
    760         //            double newIC = calculateIC(result);
    761 
    762         //            if (newIC > enigmaConfig.IC)
    763         //            {
    764         //                //better value, hence update the data
    765         //                enigmaConfig.IC = newIC;
    766         //                enigmaConfig.Ring2 = i;
    767         //                enigmaConfig.Key = settings.Alphabet[r3pos].ToString() + settings.Alphabet[rotatedR2Pos].ToString() + settings.Alphabet[r1pos].ToString();
    768         //            }
    769         //        }
    770         //    }
    771         //    else
    772         //    {
    773         //        // in case the key is fixed, we search all combinations, i.e. 26*26*26
    774         //        for (int i = 1; i <= settings.Alphabet.Length; i++)
    775         //        {
    776         //            for (int j = 1; j <= settings.Alphabet.Length; j++)
    777         //            {
    778         //                for (int k = 1; k <= settings.Alphabet.Length; k++)
    779         //                {
    780         //                    core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, k, j, i, 1, enigmaConfig.PlugBoard);
    781         //                    string result = core.Encrypt(r1pos, r2pos, r3pos, 0, text);
    782         //                    double newIC = calculateIC(result);
    783 
    784         //                    if (newIC > enigmaConfig.IC)
    785         //                    {
    786         //                        //better value, hence update the data
    787         //                        enigmaConfig.IC = newIC;
    788         //                        enigmaConfig.Ring1 = k;
    789         //                        enigmaConfig.Ring2 = j;
    790         //                        enigmaConfig.Ring2 = i;
    791         //                        enigmaConfig.Key = settings.Alphabet[r3pos].ToString() + settings.Alphabet[r2pos].ToString() + settings.Alphabet[r1pos].ToString();
    792         //                    }
    793         //                }
    794         //            }
    795         //        }
    796         //    }
    797 
    798         //    // print best option
    799         //    string msg = String.Format("ANALYSIS: Best ring setting: {0} | {1},{2},{3} | {4},{5},{6} | {7} | {8}",
    800         //        enigmaConfig.IC.ToString(),
    801         //        (rotorEnum)enigmaConfig.Rotor3, (rotorEnum)enigmaConfig.Rotor2, (rotorEnum)enigmaConfig.Rotor1,
    802         //        enigmaConfig.Ring3.ToString("00"), enigmaConfig.Ring2.ToString("00"), enigmaConfig.Ring1.ToString("00"),
    803         //        enigmaConfig.Key, pB2String(enigmaConfig.PlugBoard));
    804         //    LogMessage(msg, NotificationLevel.Info);
    805 
    806         //}
    807 
    808         //private void analyzePlugs(analysisConfigSettings enigmaConfig, int maxPlugs, string text)
    809         //{
    810         //    string tmp;
    811         //    bool plugFound = false;
    812         //    int trials = 0;
    813 
    814         //    for (int n = 0; n < maxPlugs; n++)
    815         //    {
    816 
    817         //        //LogMessage(String.Format("ANALYSIS: ====> Stage 3.{0} - Searching plugs <====",(n+1)), NotificationLevel.Info);
    818 
    819         //        tmp = enigmaConfig.PlugBoard;
    820         //        plugFound = false;
    821 
    822         //        for (int i = 0; i < settings.Alphabet.Length; i++)
    823         //        {
    824         //            for (int j = i + 1; j < settings.Alphabet.Length; j++)
    825         //            {
    826         //                //create a "clean" plugboard
    827         //                StringBuilder plugboard = new StringBuilder(tmp);
    828 
    829         //                //if both selected letters are pluged, ignore them
    830         //                if (plugboard[i] != settings.Alphabet[i] && plugboard[j] != settings.Alphabet[j])
    831         //                    continue;
    832                        
    833         //                if (plugboard[i] != settings.Alphabet[i])
    834         //                {
    835         //                    plugFound = plugFound | resolvePlugConflict(i, j, enigmaConfig, plugboard.ToString(), text);
    836         //                    trials += 3;
    837         //                    continue;
    838         //                }
    839 
    840         //                if (plugboard[j] != settings.Alphabet[j])
    841         //                {
    842         //                    plugFound = plugFound | resolvePlugConflict(j, i, enigmaConfig, plugboard.ToString(), text);
    843         //                    trials += 3;
    844         //                    continue;
    845         //                }
    846 
    847         //                //swap i with j
    848         //                plugboard[i] = settings.Alphabet[j];
    849         //                plugboard[j] = settings.Alphabet[i];
    850 
    851         //                core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, enigmaConfig.Ring1, enigmaConfig.Ring2, 1, 1, plugboard.ToString());
    852 
    853 
    854         //                int r1pos = settings.Alphabet.IndexOf(enigmaConfig.Key[2]);
    855         //                int r2pos = settings.Alphabet.IndexOf(enigmaConfig.Key[1]);
    856         //                int r3pos = settings.Alphabet.IndexOf(enigmaConfig.Key[0]);
    857         //                string result = core.Encrypt(r1pos, r2pos, r3pos, 0, text);
    858 
    859         //                double newIC = calculateIC(result);
    860         //                trials++;
    861 
    862         //                if (newIC > enigmaConfig.IC)
    863         //                {
    864         //                    enigmaConfig.IC = newIC;
    865         //                    enigmaConfig.PlugBoard = plugboard.ToString();
    866         //                    plugFound = true;
    867         //                }
    868         //            }
    869         //        }
    870 
    871 
    872         //        string msg = String.Format("ANALYSIS: Plugs setting in round {0} after {1} trials: {2} | {3},{4},{5} | {6},{7},{8} | {9} | {10}",
    873         //            (n+1),trials, enigmaConfig.IC.ToString(),
    874         //            (rotorEnum)enigmaConfig.Rotor3, (rotorEnum)enigmaConfig.Rotor2, (rotorEnum)enigmaConfig.Rotor1,
    875         //            enigmaConfig.Ring3, enigmaConfig.Ring2, enigmaConfig.Ring1,
    876         //            enigmaConfig.Key, pB2String(enigmaConfig.PlugBoard));
    877         //        LogMessage(msg, NotificationLevel.Info);
    878 
    879         //        // no plug could lead to a better result, hence abort plug search.
    880         //        if (!plugFound)
    881         //            break;
    882         //    }
    883         //}
    884 
    885         //private bool resolvePlugConflict(int conflictLetterPos, int otherLetterPos, analysisConfigSettings enigmaConfig, string unmodifiedPlugboard, string text)
    886         //{
    887         //    bool found = false;
    888 
    889         //    int pluggedLetterPos = settings.Alphabet.IndexOf(unmodifiedPlugboard[conflictLetterPos]);
    890 
    891 
    892         //    // plug otherLetter together with pluggedLetter and restore the coflictLetter
    893         //    StringBuilder o2pPlugPlugboard = new StringBuilder(unmodifiedPlugboard);
    894         //    o2pPlugPlugboard[conflictLetterPos] = settings.Alphabet[conflictLetterPos]; // restore conflictLetter
    895         //    o2pPlugPlugboard[otherLetterPos] = settings.Alphabet[pluggedLetterPos];     // swap other with
    896         //    o2pPlugPlugboard[pluggedLetterPos] = settings.Alphabet[otherLetterPos];     // plugged
    897 
    898 
    899         //    // plug conflictLetter with otherLetter and restore pluggedLetter one
    900         //    StringBuilder c2oPlugboard = new StringBuilder(unmodifiedPlugboard);
    901         //    c2oPlugboard[pluggedLetterPos] = settings.Alphabet[pluggedLetterPos]; // restore pluggedLetter
    902         //    c2oPlugboard[conflictLetterPos] = settings.Alphabet[otherLetterPos];  // swap conflictLetter
    903         //    c2oPlugboard[otherLetterPos] = settings.Alphabet[conflictLetterPos];  // with otherLetter
    904 
    905 
    906         //    // now we habe three different plug-posibilities and need to determine
    907         //    // the best one, which remains set, hence we do 3 trial encryptions
    908            
    909 
    910         //    // get the current key
    911         //    int r1pos = settings.Alphabet.IndexOf(enigmaConfig.Key[2]);
    912         //    int r2pos = settings.Alphabet.IndexOf(enigmaConfig.Key[1]);
    913         //    int r3pos = settings.Alphabet.IndexOf(enigmaConfig.Key[0]);
    914 
    915 
    916         //    // start with the unmodified
    917         //    core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, enigmaConfig.Ring1, enigmaConfig.Ring2, enigmaConfig.Ring3, 1, unmodifiedPlugboard);
    918         //    double unmodifiedIC = calculateIC(core.Encrypt(r1pos, r2pos, r3pos, 0, text));
    919 
    920         //    // now o2p
    921         //    core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, enigmaConfig.Ring1, enigmaConfig.Ring2, enigmaConfig.Ring3, 1, o2pPlugPlugboard.ToString());
    922         //    double o2pIC = calculateIC(core.Encrypt(r1pos, r2pos, r3pos, 0, text));
    923 
    924         //    // now c2o
    925         //    core.setInternalConfig(enigmaConfig.Rotor1, enigmaConfig.Rotor2, enigmaConfig.Rotor3, 0, settings.Reflector, enigmaConfig.Ring1, enigmaConfig.Ring2, enigmaConfig.Ring3, 1, c2oPlugboard.ToString());
    926         //    double c2oIC = calculateIC(core.Encrypt(r1pos, r2pos, r3pos, 0, text));
    927 
    928         //    string bestPlugBoard = enigmaConfig.PlugBoard;
    929         //    double newIC;
    930 
    931         //    if (c2oIC > unmodifiedIC)
    932         //    {
    933         //        if (c2oIC > o2pIC)
    934         //        {
    935         //            bestPlugBoard = c2oPlugboard.ToString();
    936         //            newIC = c2oIC;
    937         //        }
    938         //        else
    939         //        {
    940         //            bestPlugBoard = o2pPlugPlugboard.ToString();
    941         //            newIC = o2pIC;
    942         //        }
    943         //    }
    944         //    else
    945         //    {
    946         //        if (unmodifiedIC > o2pIC)
    947         //        {
    948         //            bestPlugBoard = unmodifiedPlugboard;
    949         //            newIC = unmodifiedIC;
    950         //        }
    951         //        else
    952         //        {
    953         //            bestPlugBoard = o2pPlugPlugboard.ToString();
    954         //            newIC = o2pIC;
    955         //        }
    956         //    }
    957 
    958 
    959         //    if (newIC > enigmaConfig.IC)
    960         //    {
    961         //        enigmaConfig.IC = newIC;
    962         //        enigmaConfig.PlugBoard = bestPlugBoard;
    963         //        found = true;
    964         //    }
    965 
    966         //    //string msg = String.Format("ANALYSIS PlUG CONFLICT: Unmodified [{0}] => {1}; Variant A [{2}] => {3}; Variant B[{4}] => {5} || Selected [{6}]",
    967         //    //    pB2String(unmodifiedPlugboard), unmodifiedIC,
    968         //    //    pB2String(c2oPlugboard.ToString()), c2oIC,
    969         //    //    pB2String(o2pPlugPlugboard.ToString()), o2pIC,
    970         //    //    pB2String(bestPlugBoard));
    971 
    972         //    //LogMessage(msg, NotificationLevel.Info);
    973 
    974         //    return found;
    975         //}
    976 
    977         #endregion
    978 
    979         #region Encryption/Decryption
    980 
    981         //private string crypt()
    982         //{
    983 
    984         //    DateTime start = DateTime.Now;
    985 
    986         //    configureEnimga();
    987 
    988         //    StringBuilder output = new StringBuilder("");
    989         //    int i = 0;
    990         //    char resultChar = '?';
    991         //    bool wasUpperCase = false;
    992 
    993         //    // re-set the key to initial value..
    994         //    //settings.Key = initialKey;
    995            
    996 
    997 
    998         //    // now process each letter
    999         //    foreach (char c in inputString.ToCharArray())
    1000         //    {
    1001         //        if (settings.Action == 0) EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(i++, inputString.Length));
    1002 
    1003         //        wasUpperCase = char.IsUpper(c);
    1004         //        char upperC = char.ToUpper(c);
    1005 
    1006         //        if (settings.Alphabet.Contains(upperC))
    1007         //        {
    1008         //            resultChar = enigmacrypt(upperC);
    1009 
    1010         //        }
    1011         //        else
    1012         //        {
    1013         //            switch (settings.UnknownSymbolHandling)
    1014         //            {
    1015         //                case 0: // ignore
    1016         //                    resultChar = c;
    1017         //                    break;
    1018         //                case 1: // remove
    1019         //                    continue;
    1020         //                case 2: // replace by X
    1021         //                    resultChar = enigmacrypt('X');
    1022         //                    break;
    1023         //            }
    1024         //        }
    1025 
    1026 
    1027         //        // case handling
    1028         //        switch (settings.CaseHandling)
    1029         //        {
    1030         //            case 0: // preserve
    1031         //                if (wasUpperCase)
    1032         //                    resultChar = char.ToUpper(resultChar);
    1033         //                else
    1034         //                    resultChar = char.ToLower(resultChar);
    1035         //                break;
    1036         //            case 1: // upper
    1037         //                resultChar = char.ToUpper(resultChar);
    1038         //                break;
    1039         //            case 2: // lower
    1040         //                resultChar = char.ToLower(resultChar);
    1041         //                break;
    1042         //        }
    1043 
    1044 
    1045         //        // append the calculated value to the output
    1046         //        output.Append(resultChar);
    1047         //    }
    1048 
    1049         //    procTime = DateTime.Now.Subtract(start);
    1050 
    1051         //    return output.ToString();
    1052         //}
    1053 
    1054         //private void configureEnimga()
    1055         //{
    1056         //    // set some helper variables
    1057         //    A = settings.Alphabet + settings.Alphabet + settings.Alphabet;
    1058         //    aLength = settings.Alphabet.Length;
    1059 
    1060         //    // prepare the current string for the forward substitution. We use a the string 3-times, since this saves some alphabet wrap-arround checking
    1061         //    rotor1For = rotors[settings.Model, settings.Rotor1] + rotors[settings.Model, settings.Rotor1] + rotors[settings.Model, settings.Rotor1];
    1062         //    rotor2For = rotors[settings.Model, settings.Rotor2] + rotors[settings.Model, settings.Rotor2] + rotors[settings.Model, settings.Rotor2];
    1063         //    rotor3For = rotors[settings.Model, settings.Rotor3] + rotors[settings.Model, settings.Rotor3] + rotors[settings.Model, settings.Rotor3];
    1064         //    if (settings.Rotor4 < 8)
    1065         //    {
    1066         //        rotor4For = rotors[settings.Model, settings.Rotor4] + rotors[settings.Model, settings.Rotor4] + rotors[settings.Model, settings.Rotor4];
    1067         //    }
    1068 
    1069 
    1070         //    if (settings.Model > 0) // the Enigma A/B did not have a reflector, hence there is no reverse substitution
    1071         //    {
    1072         //        // prepare the current string for the reflector
    1073         //        reflector = reflectors[settings.Model, settings.Reflector] + reflectors[settings.Model, settings.Reflector] + reflectors[settings.Model, settings.Reflector];
    1074 
    1075         //        // prepare the current string for the reverse substitution.
    1076         //        rotor1Rev = generateReverseSubst(rotors[settings.Model, settings.Rotor1]);
    1077         //        rotor1Rev += rotor1Rev + rotor1Rev;
    1078         //        rotor2Rev = generateReverseSubst(rotors[settings.Model, settings.Rotor2]);
    1079         //        rotor2Rev += rotor2Rev + rotor2Rev;
    1080         //        rotor3Rev = generateReverseSubst(rotors[settings.Model, settings.Rotor3]);
    1081         //        rotor3Rev += rotor3Rev + rotor3Rev;
    1082         //        if (settings.Rotor4 < 8)
    1083         //        {
    1084         //            rotor4Rev = generateReverseSubst(rotors[settings.Model, settings.Rotor4]);
    1085         //            rotor4Rev += rotor4Rev + rotor4Rev;
    1086         //        }
    1087         //    }
    1088         //    // configure rotor notches
    1089         //    rotor1notches = notches[settings.Rotor1];
    1090         //    rotor2notches = notches[settings.Rotor2];
    1091         //    rotor3notches = notches[settings.Rotor3];
    1092 
    1093 
    1094         //    //retrieve the current key from the settings           
    1095         //    //currentKey[3] = settings.Key[settings.Key.Length - 1];
    1096         //    //currentKey[2] = settings.Key[settings.Key.Length - 2];
    1097         //    //currentKey[1] = settings.Key[settings.Key.Length - 3];
    1098         //    //if (settings.Key.Length == 4) currentKey[0] = settings.Key[settings.Key.Length - 4];
    1099         //}
    1100 
    1101         //private char enigmacrypt(char keyPressed)
    1102         //{
    1103         //    //1. Substitution with plugboard
    1104         //    char entrySubst = this.settings.PlugBoard(keyPressed);
    1105 
    1106         //    //2. Spindle substitution
    1107         //    char spindleSubst = enigmaSpindle(entrySubst);
    1108 
    1109         //    //3. Substitution with plugboard
    1110         //    return this.settings.PlugBoard(spindleSubst);
    1111         //}
    1112 
    1113         //private char enigmaSpindle(char entrySubst)
    1114         //{
    1115 
    1116         //    char ch = entrySubst;
    1117 
    1118 
    1119         //    // get the position of each rotor           
    1120         //    int rotor1Pos = settings.Alphabet.IndexOf(currentKey[3]);
    1121         //    int rotor2Pos = settings.Alphabet.IndexOf(currentKey[2]);
    1122         //    int rotor3Pos = settings.Alphabet.IndexOf(currentKey[1]);
    1123         //    int rotor4Pos = settings.Alphabet.IndexOf(currentKey[0]);
    1124 
    1125 
    1126         //    //check notches and update the rotor position
    1127         //    foreach (char n in rotor1notches)
    1128         //    {
    1129         //        if (n == currentKey[3]) rotor2Pos = (rotor2Pos + 1) % aLength;
    1130         //    }
    1131 
    1132         //    foreach (char n in rotor2notches)
    1133         //    {
    1134         //        if (n == currentKey[2]) rotor3Pos = (rotor3Pos + 1) % aLength;
    1135         //    }
    1136 
    1137         //    foreach (char n in rotor3notches)
    1138         //    {
    1139         //        if (n == currentKey[1]) rotor4Pos = (rotor4Pos + 1) % aLength;
    1140         //    }
    1141 
    1142         //    rotor1Pos = (rotor1Pos + 1) % aLength;
    1143 
    1144         //    currentKey[3] = A[rotor1Pos];
    1145         //    currentKey[2] = A[rotor2Pos];
    1146         //    currentKey[1] = A[rotor3Pos];
    1147         //    currentKey[0] = A[rotor4Pos];
    1148 
    1149         //    // write back the updated rotor settings
    1150         //    //settings.Key = new string(currentKey);
    1151 
    1152         //    //add the ring-offset
    1153         //    rotor1Pos = (aLength + rotor1Pos - (settings.Ring1 - 1)) % aLength;
    1154         //    rotor2Pos = (aLength + rotor2Pos - (settings.Ring2 - 1)) % aLength;
    1155         //    rotor3Pos = (aLength + rotor3Pos - (settings.Ring3 - 1)) % aLength;
    1156 
    1157         //    // now do the substitution
    1158         //    ch = A[aLength + A.IndexOf(rotor1For[aLength + A.IndexOf(ch) + rotor1Pos]) - rotor1Pos];
    1159         //    ch = A[aLength + A.IndexOf(rotor2For[aLength + A.IndexOf(ch) + rotor2Pos]) - rotor2Pos];
    1160         //    ch = A[aLength + A.IndexOf(rotor3For[aLength + A.IndexOf(ch) + rotor3Pos]) - rotor3Pos];
    1161         //    ch = reflector[aLength + A.IndexOf(ch)];
    1162         //    ch = A[aLength + A.IndexOf(rotor3Rev[aLength + A.IndexOf(ch) + rotor3Pos]) - rotor3Pos];
    1163         //    ch = A[aLength + A.IndexOf(rotor2Rev[aLength + A.IndexOf(ch) + rotor2Pos]) - rotor2Pos];
    1164         //    ch = A[aLength + A.IndexOf(rotor1Rev[aLength + A.IndexOf(ch) + rotor1Pos]) - rotor1Pos];
    1165 
    1166         //    return ch;
    1167         //}
    1168 
    1169         //private string generateReverseSubst(string p)
    1170         //{
    1171         //    char[] result = new char[aLength];
    1172 
    1173         //    for (int i = 0; i < aLength; i++)
    1174         //    {
    1175         //        result[i] = settings.Alphabet[p.IndexOf(settings.Alphabet[i])];
    1176         //    }
    1177 
    1178         //    return new string(result);
    1179         //}
    1180332
    1181333        #endregion
     
    1272424                        settings.Reflector, settings.Ring1, settings.Ring2, settings.Ring3, settings.Ring4,
    1273425                        settings.PlugBoard);
    1274            
    1275             // re-set the stop-flag
    1276             //stop = false;
    1277426        }
    1278427
     
    1323472
    1324473                    ShowProgress(1000, 1000);
    1325                    
    1326                     // old version
    1327                     //runAnalysis(inputString);
    1328474                    break;
    1329475                default:
     
    1351497        {
    1352498            LogMessage("Enigma stopped", NotificationLevel.Info);
    1353             //stop = true;
    1354499            analyzer.StopAnalysis();
    1355500        }
Note: See TracChangeset for help on using the changeset viewer.