Changeset 8887


Ignore:
Timestamp:
Sep 15, 2020, 2:44:38 PM (16 months ago)
Author:
kopal
Message:

EnigmaAnalyzer:

  • only new bestlist entries (key and plaintext) for place one are now forwarded to outputs

Enigma:

  • Enigma now accepts keys in the same format as the analyzer outputs
Location:
trunk/CrypPlugins
Files:
3 edited

Legend:

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

    r8588 r8887  
    5454        private string _textInput;
    5555        private string _keyInput;
    56         private IDictionary<int, IDictionary<string, double[]>> _statistics;
    57         // FIXME: enable optional statistics input
    58         //private IDictionary<string, double[]> inputTriGrams;
     56        private IDictionary<int, IDictionary<string, double[]>> _statistics;       
    5957        private string _textOutput;
    60         private string _savedInitialRotorPos;
     58
    6159        public bool _isrunning;
    62         private bool _newText = false;
    63         private bool _keyInputConnected = false;
    64         private bool _newKey = false;
    6560
    6661        private bool _running = false;
     
    8681        private string FormattedEncrypt(int rotor1Pos, int rotor2Pos, int rotor3Pos, int rotor4Pos, string text)
    8782        {
    88             String input = preFormatInput(text);
     83            string input = preFormatInput(text);
    8984            _enigmaPresentationFrame.ChangeStatus(_isrunning, _enigmaPresentationFrame.EnigmaPresentation.IsVisible);
    9085
    9186            if (Presentation.IsVisible && _enigmaPresentationFrame.EnigmaPresentation.PresentationDisabled.DisabledBoolProperty)
    9287            {
    93                 String output = _core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos, rotor4Pos, input);
    94 
     88                string output = _core.Encrypt(rotor1Pos, rotor2Pos, rotor3Pos, rotor4Pos, input);
    9589                _enigmaPresentationFrame.EnigmaPresentation.output = output;
    9690                if (_enigmaPresentationFrame.EnigmaPresentation.checkReady())
     91                {
    9792                    _enigmaPresentationFrame.EnigmaPresentation.setinput(input);
     93                }
    9894                else
     95                {
    9996                    LogMessage("Presentation Error!", NotificationLevel.Error);
    100                 //myPresentation.playClick(null, EventArgs.Empty);
    101                 //return postFormatOutput(output);
    102                
    103                 return "";
     97                }               
     98                return string.Empty;
    10499            }
    105100
     
    303298        public string TextInput
    304299        {
    305             get { return this._textInput; }
     300            get
     301            {
     302                return _textInput;
     303            }
    306304            set
    307             {
    308                 if (!_isrunning)
    309                 {
    310                     return;
    311                 }
     305            {               
    312306                if (value != _textInput)
    313307                {
    314                     this._textInput = value;
    315                     this._newText = true;
     308                    _textInput = value;
    316309                    OnPropertyChanged("TextInput");
    317310                }
     
    322315        public string KeyInput
    323316        {
    324             get { return this._keyInput; }
     317            get
     318            {
     319                return _keyInput;
     320            }
    325321            set
    326322            {
     
    329325                    return;
    330326                }
    331                 this._keyInputConnected = true;
    332                 if (!String.IsNullOrEmpty(value) && value != this._keyInput)
    333                 {
    334                     this._keyInput = value;
    335                     this._newKey = true;
    336                     OnPropertyChanged("KeyInput");
    337                     _settings.SetKeySettings(value);
     327                if (!string.IsNullOrEmpty(value) && value != _keyInput)
     328                {
     329                    _keyInput = value;
     330                    OnPropertyChanged("KeyInput");                   
    338331                }
    339332            }
     
    343336        public string TextOutput
    344337        {
    345             get { return this._textOutput; }
     338            get
     339            {
     340                return _textOutput;
     341            }
    346342            set
    347343            {
     
    357353        public void PreExecution()
    358354        {
     355           
     356        }
     357
     358        public void Execute()
     359        {
     360            if (!string.IsNullOrEmpty(KeyInput))
     361            {             
     362                _settings.SetKeySettings(KeyInput);
     363            }
     364            if (_settings.Model != 3 && _settings.Model != 2)
     365            {
     366                LogMessage("This simulator is work in progress. As of right now only Enigma I and Enigma Reichsbahn (Rocket) is supported!!", NotificationLevel.Error);
     367                return;
     368            }
     369
    359370            _isrunning = true;
    360 
    361371            _running = false;
    362372            _stopped = false;
    363373
    364374            if (_enigmaPresentationFrame.EnigmaPresentation.checkReady())
     375            {
    365376                _enigmaPresentationFrame.EnigmaPresentation.stopclick(this, EventArgs.Empty);
    366             EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs("Preparing enigma for operation..", this,  NotificationLevel.Info));
    367 
    368             if (_settings.Model != 3 && _settings.Model != 2)
    369             {
    370                 EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs("This simulator is work in progress. As of right now only Enigma I and Enigma Reichsbahn (Rocket) is supported!!", this, NotificationLevel.Warning));
    371                 return;
    372             }
    373 
    374             // remember the current key-setting, in order to restore on stop
    375             _savedInitialRotorPos = _settings.InitialRotorPos;
    376 
    377             //configure the enigma
     377            }
     378
     379            //configure the Enigma
    378380            _core.setInternalConfig(_settings.Rotor1, _settings.Rotor2, _settings.Rotor3, _settings.Rotor4,
    379381                        _settings.Reflector, _settings.Ring1, _settings.Ring2, _settings.Ring3, _settings.Ring4,
    380382                        _settings.PlugBoard);
    381         }
    382 
    383         public void Execute()
    384         {
    385             if (!this._newText || this._keyInputConnected && !this._newKey)
    386                 return;
    387 
    388             this._newText = false;
    389             this._newKey = false;
    390 
    391             if (_settings.Model != 3 && _settings.Model != 2)
    392             {
    393                 LogMessage("This simulator is work in progress. As of right now only Enigma I and Enigma Reichsbahn (Rocket) is supported!!", NotificationLevel.Error);
    394                 return;
    395             }
    396 
    397             while(_running)
     383
     384            while (_running)
    398385            {
    399386                _enigmaPresentationFrame.EnigmaPresentation.stopclick(this, EventArgs.Empty);
    400387                if (_stopped)
    401                 return;
    402             }
    403 
    404             _running = true;
    405             LogMessage("Enigma encryption/decryption started...", NotificationLevel.Info);
     388                {
     389                    return;
     390                }
     391            }
     392
     393            _running = true;         
    406394
    407395            // re-set the key, in case we get executed again during single run
     
    413401                _settings.Alphabet.IndexOf(_settings.InitialRotorPos[0]),
    414402                0, _textInput);                   
    415 
    416             // FIXME: output all scorings
    417             //LogMessage("Enigma encryption done. The resulting index of coincidences is " + analyzer.calculateScore(outputString, 0), NotificationLevel.Info);
    418 
     403         
    419404            // "fire" the output
    420405            OnPropertyChanged("TextOutput");
     406
     407            LogMessage("Decrypted with key: " + KeyInput, NotificationLevel.Info);
    421408        }
    422409
    423410        public void PostExecution()
    424411        {
    425             _keyInput = String.Empty;
    426             _textInput = String.Empty;
    427             _newKey = false;
    428             _newText = false;
     412            _keyInput = string.Empty;
     413            _textInput = string.Empty;
    429414            _running = false;
    430415            _isrunning = false;
  • trunk/CrypPlugins/Enigma/EnigmaSettings.cs

    r8359 r8887  
    167167        public void SetKeySettings(string inputKey)
    168168        {
    169             // delete the spaces
    170             inputKey = inputKey.Replace(" ", String.Empty);
    171             inputKey = inputKey.Replace("\n", String.Empty);
    172             inputKey = inputKey.Replace("\r", String.Empty);
    173 
    174             // count slashes
    175             int slashes = inputKey.Count(x => x == '/');
    176 
    177             // search slash indices
    178             int firstSlashIndex = inputKey.IndexOf('/');
    179             int secondSlashIndex = 0;
    180             if (slashes > 1)
    181                 secondSlashIndex = (inputKey.Substring(firstSlashIndex + 1)).IndexOf('/') + firstSlashIndex + 1;
    182             int thirdSlashIndex = 0;
    183             if (slashes > 2)
    184                 thirdSlashIndex = (inputKey.Substring(secondSlashIndex + 1)).IndexOf('/') + secondSlashIndex + 1;
    185            
    186             // trim different parts of the key
    187             string rotorString = inputKey.Substring(0, firstSlashIndex);
    188             string ringString = inputKey.Substring(firstSlashIndex + 1);
    189             if (slashes > 1)
    190                 ringString = inputKey.Substring(firstSlashIndex + 1, secondSlashIndex - firstSlashIndex - 1);
    191 
    192             string plugBoardString = "";
    193             if (slashes > 1)
    194                 plugBoardString = inputKey.Substring(secondSlashIndex + 1);
    195 
    196             string initialRotorPosString = "";
    197             if (slashes > 2)
    198             {
    199                 plugBoardString = inputKey.Substring(secondSlashIndex + 1, thirdSlashIndex - secondSlashIndex - 1);
    200                 initialRotorPosString = inputKey.Substring(thirdSlashIndex + 1);
    201             }
    202 
    203             // set settings by strings
     169            const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     170            // delete whitespaces
     171            inputKey = inputKey.Replace(" ", string.Empty).Replace("\n", string.Empty).Replace("\r", string.Empty);
     172            inputKey = inputKey.ToUpper();
     173
     174            string[] keyElements = inputKey.Split(':');
     175
     176            if(keyElements.Length != 4)
     177            {
     178                throw new Exception("Invalid key. Key has to be of the following format:  Reflector:Rotors:Ring:RotorPositions|Plugboard");
     179            }
     180
     181            string reflectorString = keyElements[0];
     182            string rotorString = keyElements[1];
     183            string ringString = keyElements[2];
     184            string[] split = keyElements[3].Split('|');
     185            _initialRotorPos = split[0];
     186            string plugBoardString = null;           
     187            if(split.Length == 2)
     188            {
     189                plugBoardString = split[1];
     190            }
     191
     192            if(rotorString.Length < 3 || rotorString.Length > 4)
     193            {
     194                throw new Exception("Invalid key. You have to define 3 or 4 rotors, depending on selected machine model");
     195            }
     196
     197            if(ringString.Length != rotorString.Length || _initialRotorPos.Length != rotorString.Length)
     198            {
     199                throw new Exception("Invalid key. You have to define same number of rotors, rings, and rotor positions");
     200            }           
     201
     202            SetReflectorByString(reflectorString);
    204203            SetRotorsByString(rotorString);
    205204            SetRingByString(ringString);
    206             if (slashes > 1)
     205            if (plugBoardString != null)
     206            {
    207207                SetPlugBoardByString(plugBoardString);
    208             if (slashes > 2)
    209             {
    210                 _initialRotorPos = initialRotorPosString;
    211                 OnPropertyChanged("InitialRotorPos");
     208            }
     209            OnPropertyChanged("InitialRotorPos");           
     210            foreach (var c in _initialRotorPos)
     211            {
     212                if(alphabet.IndexOf(c) < 0)
     213                {
     214                    throw new Exception("Invalid key. Rotor positions have to be defined from A to Z");
     215                }
     216            }
     217        }
     218       
     219        private void SetReflectorByString(string reflectorString)
     220        {
     221            const string reflectors = "ABC";
     222            Reflector = reflectors.IndexOf(reflectorString.ToUpper());
     223            if(Reflector < 0)
     224            {
     225                throw new Exception("Invalid key. Reflector has to be A,B, or C");
    212226            }
    213227        }
     
    215229        private void SetRotorsByString(string rotorString)
    216230        {
    217             string[] rotors = rotorString.Split(',');
    218             rotor1 = GetRotorIndexFromString(rotors[0]);
    219             rotor2 = GetRotorIndexFromString(rotors[1]);
    220             rotor3 = GetRotorIndexFromString(rotors[2]);
    221             if (rotors.Length > 3)
    222             {
    223                 rotor4 = GetRotorIndexFromString(rotors[3]);
     231            const string rotorNumbers = "12345678";
     232            if (rotorString.Length == 3)
     233            {
     234                rotor1 = rotorNumbers.IndexOf(rotorString[2]);
     235                rotor2 = rotorNumbers.IndexOf(rotorString[1]);
     236                rotor3 = rotorNumbers.IndexOf(rotorString[0]);
     237                OnPropertyChanged("Rotor1");
     238                OnPropertyChanged("Rotor2");
     239                OnPropertyChanged("Rotor3");
     240            }
     241            else
     242            {
     243                rotor1 = rotorNumbers.IndexOf(rotorString[3]);
     244                rotor2 = rotorNumbers.IndexOf(rotorString[2]);
     245                rotor3 = rotorNumbers.IndexOf(rotorString[1]);
     246                rotor4 = rotorNumbers.IndexOf(rotorString[0]);
     247                OnPropertyChanged("Rotor1");
     248                OnPropertyChanged("Rotor2");
     249                OnPropertyChanged("Rotor3");
    224250                OnPropertyChanged("Rotor4");
    225             }
    226 
    227             OnPropertyChanged("Rotor1");
    228             OnPropertyChanged("Rotor2");
    229             OnPropertyChanged("Rotor3");
    230         }
    231 
    232         string[] rotorNames = { "I", "II", "III", "IV", "V", "VI", "VII", "VIII" };
    233         private int GetRotorIndexFromString(string indexString)
    234         {
    235             return Array.IndexOf(rotorNames, indexString);
    236         }
     251            }                   
     252           
     253            if (rotor1 < 0 || rotor2 < 0 || rotor3 < 0 || (rotorString.Length == 4 && rotor4 < 0))
     254            {
     255                throw new Exception("Invalid key. Rotors have to be defined from A to Z");
     256            }
     257         
     258        }       
    237259
    238260        private void SetRingByString(string ringString)
    239261        {
    240             string[] rings = ringString.Split(',');
    241            
    242             int value1, value2, value3, value4 = -1;
    243 
    244             if (!Int32.TryParse(rings[0], out value1) ||
    245                 !Int32.TryParse(rings[1], out value2) ||
    246                 !Int32.TryParse(rings[2], out value3) ||
    247                 rings.Length > 3 && !Int32.TryParse(rings[3], out value4))
    248             {
    249                 Console.WriteLine("Error parsing the InputKey ring settings!");
    250                 return;
    251             }
    252 
    253             ring1 = value1;
    254             ring2 = value2;
    255             ring3 = value3;
    256             if (rings.Length > 3)
    257             {
    258                 ring4 = value4;
     262            const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     263            ringString = ringString.ToUpper();
     264            if (ringString.Length == 3)
     265            {
     266                ring1 = alphabet.IndexOf(ringString[2]) + 1;
     267                ring2 = alphabet.IndexOf(ringString[1]) + 1;
     268                ring3 = alphabet.IndexOf(ringString[0]) + 1;
     269                OnPropertyChanged("Ring1");
     270                OnPropertyChanged("Ring2");
     271                OnPropertyChanged("Ring3");
     272            }
     273            else
     274            {
     275                ring1 = alphabet.IndexOf(ringString[3]) + 1;
     276                ring2 = alphabet.IndexOf(ringString[2]) + 1;
     277                ring3 = alphabet.IndexOf(ringString[1]) + 1;
     278                ring4 = alphabet.IndexOf(ringString[0]) + 1;
     279                OnPropertyChanged("Ring1");
     280                OnPropertyChanged("Ring2");
     281                OnPropertyChanged("Ring3");
    259282                OnPropertyChanged("Ring4");
    260283            }
    261 
    262             OnPropertyChanged("Ring1");
    263             OnPropertyChanged("Ring2");
    264             OnPropertyChanged("Ring3");
     284            if (ring1 < 1 || ring2 < 1 || ring3 < 1 || (ringString.Length == 4 && ring4 < 1))
     285            {
     286                throw new Exception("Invalid key. Rings have to be defined from A to Z");
     287            }           
    265288        }
    266289
    267290        private void SetPlugBoardByString(string plugBoardString)
    268291        {
     292            const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     293
     294            if(plugBoardString.Length % 2 != 0)
     295            {
     296                throw new Exception("Invalid key. Plugboard definition has to be of even length");
     297            }
     298
    269299            ResetPlugboard();
    270             string[] plugBoardStringArray = plugBoardString.Split(',');
    271 
    272             for (int i = 0; i < plugBoardStringArray.Length; i++)
    273             {
    274                 int indexLetterOne = alphabet.IndexOf(plugBoardStringArray[i].Substring(0, 1));
    275                 int indexLetterTwo = alphabet.IndexOf(plugBoardStringArray[i].Substring(1, 1));
     300            plugBoardString = plugBoardString.ToUpper();
     301
     302            for (int i = 0; i < plugBoardString.Length; i+=2)
     303            {
     304                int indexLetterOne = alphabet.IndexOf(plugBoardString[i]);
     305                int indexLetterTwo = alphabet.IndexOf(plugBoardString[i + 1]);
     306                if(indexLetterOne < 0 || indexLetterTwo < 0)
     307                {
     308                    throw new Exception("Invalid key. Plugboard has to be defined from A to Z");
     309                }
    276310                setPlugBoard(indexLetterOne, indexLetterTwo);
    277311                setPlugBoard(indexLetterTwo, indexLetterOne);
  • trunk/CrypPlugins/EnigmaAnalyzer/EnigmaAnalyzer.cs

    r8886 r8887  
    253253            _resultReporter.OnGuiLogNotificationOccured += OnGuiLogNotificationOccured;
    254254            _resultReporter.OnPluginProgressChanged += OnPluginProgressChanged;
    255             _resultReporter.OnNewBestKey += _resultReporter_OnNewBestKey;
    256             _resultReporter.OnNewBestPlaintext += _resultReporter_OnNewBestPlaintext;
    257255            _resultReporter.OnNewBestlistEntry += _resultReporter_OnNewBestlistEntry;
    258256            _resultReporter.OnNewCryptanalysisStep += _resultReporter_OnNewCryptanalysisStep;
     
    334332                        ranking++;
    335333                    }
     334
     335                    //if we have a new number 1, we output it
     336                    if(args.ResultEntry.Ranking == 1)
     337                    {
     338                        Plaintext = args.ResultEntry.Text;
     339                        Key = args.ResultEntry.Key;
     340                    }
    336341                }
    337342                catch (Exception)
     
    340345                }
    341346            }, null);
    342         }
    343 
    344         /// <summary>
    345         /// We received a new best plaintext from the analysis and output it
    346         /// </summary>
    347         /// <param name="args"></param>
    348         private void _resultReporter_OnNewBestPlaintext(NewBestPlaintextEventArgs args)
    349         {
    350             Plaintext = args.Plaintext;
    351         }
    352 
    353         /// <summary>
    354         /// We received a new best key from the analysis and output it
    355         /// </summary>
    356         /// <param name="args"></param>
    357         private void _resultReporter_OnNewBestKey(NewBestKeyEventArgs args)
    358         {
    359             Key = args.Key;
    360         }
     347        }               
    361348
    362349        /// <summary>
Note: See TracChangeset for help on using the changeset viewer.