Ignore:
Timestamp:
Jul 30, 2009, 5:15:52 PM (12 years ago)
Author:
Matthäus Wander
Message:

CrypPluginBase:

  • minor: added plugin path information

EnigmaAnalyzer:

  • added default bigram/trigram frequencies as txt files
  • added intermediate result output during plug search
Location:
trunk/CrypPlugins/Enigma
Files:
2 added
4 edited

Legend:

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

    r404 r408  
    220220using Cryptool.PluginBase.Miscellaneous;
    221221using Cryptool.PluginBase.IO;
     222using System.IO;
     223using System.Reflection;
     224using System.Resources;
    222225
    223226
     
    231234    public class Enigma: IEncryption
    232235    {
    233         #region Private variables
     236        #region Private variables and constants
     237
     238        internal const int ABSOLUTE = 0;
     239        internal const int PERCENTAGED = 1;
     240        internal const int LOG2 = 2;
    234241
    235242        private EnigmaSettings settings;
     
    334341        #endregion
    335342
    336         #endregion
    337 
    338         #region Contstructor
     343        #region n-gram frequencies
     344
     345        private IDictionary<string, double[]> LoadDefaultStatistics(int length)
     346        {
     347            SortedDictionary<string, double[]> grams = new SortedDictionary<string, double[]>();
     348
     349            StreamReader reader = new StreamReader(Path.Combine(PluginResource.directoryPath, GetStatisticsFilename(length)));
     350
     351            string line;
     352
     353            while ((line = reader.ReadLine()) != null)
     354            {
     355                if (line.StartsWith("#"))
     356                    continue;
     357
     358                string[] tokens = new WordTokenizer(line).ToArray();
     359                Debug.Assert(tokens.Length == 2, "Expected 2 tokens, found " + tokens.Length + " on one line");
     360
     361                grams.Add(tokens[0], new double[] { Double.Parse(tokens[1]), 0, 0 });
     362            }
     363
     364            double sum = grams.Values.Sum(item => item[ABSOLUTE]);
     365            LogMessage("Sum of all n-gram counts is: " + sum, NotificationLevel.Debug);
     366
     367            // calculate scaled values
     368            foreach (double[] g in grams.Values)
     369            {
     370                g[PERCENTAGED] = g[ABSOLUTE] / sum;
     371                g[LOG2] = Math.Log(g[ABSOLUTE], 2);
     372            }
     373
     374            return grams;
     375        }
     376
     377        /// <summary>
     378        /// Get file name for default n-gram frequencies.
     379        /// </summary>
     380        /// <param name="length"></param>
     381        /// <exception cref="NotSupportedException">No default n-gram frequencies available</exception>
     382        /// <returns></returns>
     383        private string GetStatisticsFilename(int length)
     384        {
     385            switch(length)
     386            {
     387                case 2:
     388                    return "Enigma_BigramFrequency1941.txt";
     389                case 3:
     390                    return "Enigma_TrigramFrequency1941.txt";
     391                default:
     392                    throw new NotSupportedException("There is no known default statistic for an n-gram length of " + length);
     393            }
     394        }
     395
     396        #endregion
     397
     398        #endregion
     399
     400        #region Constructor
    339401
    340402        public Enigma()
     
    393455        }
    394456
    395         [PropertyInfo(Direction.Input, "n-gram dictionary", "Dictionary with gram counts", "", false, false, DisplayLevel.Experienced, QuickWatchFormat.Text, "FrequencyTest.QuickWatchDictionary")]
     457        [PropertyInfo(Direction.Input, "n-gram dictionary", "Dictionary with gram counts (string -> [absolute, percentaged, log2])", "", false, false, DisplayLevel.Experienced, QuickWatchFormat.Text, "FrequencyTest.QuickWatchDictionary")]
    396458        public IDictionary<string, double[]> InputGrams
    397459        {
     
    478540                    LogMessage("Enigma analysis starting ...", NotificationLevel.Info);
    479541
     542                    if (inputGrams == null && settings.PlugSearchMethod >= 1)
     543                    {
     544                        LogMessage("No n-gram statistics given, trying to load defaults", NotificationLevel.Info);
     545                        try
     546                        {
     547                            inputGrams = LoadDefaultStatistics(settings.GetGramLength());
     548                        }
     549                        catch (NotSupportedException e)
     550                        {
     551                            LogMessage(e.Message, NotificationLevel.Error);
     552                            return;
     553                        }
     554                    }
     555
     556                    if (inputGrams != null && settings.PlugSearchMethod == 0)
     557                    {
     558                        LogMessage("The connected n-gram dictionary won't be used by selected plug search method (IC)", NotificationLevel.Warning);
     559                    }
     560                    if (inputGrams != null && inputGrams.Count > 0)
     561                    {
     562                        if (inputGrams.First().Key.Length != settings.GetGramLength())
     563                        {
     564                            LogMessage("The length of the used n-gram statistics does not match the selected plug search method", NotificationLevel.Warning);
     565                        }
     566                    }
     567
    480568                    //prepare for analysis
    481569                    LogMessage("ANALYSIS: Preformatting text...", NotificationLevel.Debug);
  • trunk/CrypPlugins/Enigma/Enigma.csproj

    r353 r408  
    8080  </ItemGroup>
    8181  <ItemGroup>
     82    <None Include="Enigma_BigramFrequency1941.txt">
     83      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     84    </None>
     85    <None Include="Enigma_TrigramFrequency1941.txt">
     86      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     87    </None>
     88  </ItemGroup>
     89  <ItemGroup>
    8290    <Folder Include="DetailedDescription\" />
    8391  </ItemGroup>
     
    95103if not exist "./CrypPlugins" mkdir "./CrypPlugins"
    96104
    97 del /F /S /Q /s /q "Enigma.*"
    98 copy "$(TargetDir)Enigma.*" "./CrypPlugins"</PostBuildEvent>
     105del /F /S /Q /s /q "Enigma*"
     106copy "$(TargetDir)Enigma*" "./CrypPlugins"</PostBuildEvent>
    99107  </PropertyGroup>
    100108</Project>
  • trunk/CrypPlugins/Enigma/EnigmaAnalyzer.cs

    r404 r408  
    4949
    5050        #region Private member variables and constants
    51 
    52         private const int ABSOLUTE = 0;
    53         private const int PERCENTAGED = 1;
    54         private const int LOG2 = 2;
    5551
    5652        Enigma pluginFacade;
     
    378374        /// <param name="maxPlugs">The maximum numer of plugs to be searched. Note that if no more improvement can be found the algortihm may terminate earlier</param>
    379375        /// <param name="text">The cipertext</param>
    380         private void analyzePlugs(analysisConfigSettings enigmaConfig, int maxPlugs, string text)
     376        /// <returns>best decrypted result string</returns>
     377        private string analyzePlugs(analysisConfigSettings enigmaConfig, int maxPlugs, string text)
    381378        {
    382379            string tmp;
    383380            bool plugFound = false;
    384381            int trials = 0;
    385             enigmaConfig.Score = calculatePlugScore(encrypt(enigmaConfig, text, enigmaConfig.PlugBoard));
     382            string bestResult = encrypt(enigmaConfig, text, enigmaConfig.PlugBoard);
     383            enigmaConfig.Score = calculatePlugScore(bestResult);
    386384
    387385            if (grams == null)
     
    428426                        plugboard[j] = settings.Alphabet[i];
    429427
    430                         double newScore = calculatePlugScore(encrypt(enigmaConfig, text, plugboard.ToString()));
     428                        string result = encrypt(enigmaConfig, text, plugboard.ToString());
     429                        double newScore = calculatePlugScore(result);
    431430                        trials++;
    432431
     
    435434                            enigmaConfig.Score = newScore;
    436435                            enigmaConfig.PlugBoard = plugboard.ToString();
     436                            bestResult = result;
    437437                            plugFound = true;
    438438                        }
     
    452452                    break;
    453453            }
     454
     455            return bestResult;
    454456        }
    455457
     
    618620                if (workstring.Contains(settings.CaseHandling == 0 ? item.Key : item.Key.ToUpper()))
    619621                {
    620                     score += item.Value[LOG2];
     622                    score += item.Value[Enigma.LOG2];
    621623                }
    622624            }
     
    672674
    673675        #endregion
    674 
    675676
    676677        #region Properties
     
    780781                for (int j = analysisCandidates.Count - 1; j >= 0; j--)
    781782                {
    782                     analyzePlugs(analysisCandidates[j], settings.MaxSearchedPlugs, preformatedText);
     783                    string result = analyzePlugs(analysisCandidates[j], settings.MaxSearchedPlugs, preformatedText);
     784
     785                    // fire the event, so someting becomes visible..
     786                    if (OnIntermediateResult != null)
     787                    {
     788                        OnIntermediateResult(this, new IntermediateResultEventArgs() { Result = result });
     789                    }
    783790                }
    784791
     
    806813            analysisConfigSettings bestConfig = analysisCandidates[analysisCandidates.Count - 1];
    807814
    808             core.setInternalConfig(bestConfig.Rotor1, bestConfig.Rotor2, bestConfig.Rotor3, 0, settings.Reflector, bestConfig.Ring1, bestConfig.Ring2, bestConfig.Ring3, 1, bestConfig.PlugBoard);
    809             int r1p = settings.Alphabet.IndexOf(bestConfig.Key[2]);
    810             int r2p = settings.Alphabet.IndexOf(bestConfig.Key[1]);
    811             int r3p = settings.Alphabet.IndexOf(bestConfig.Key[0]);
    812             return core.Encrypt(r1p, r2p, r3p, 0, preformatedText);
     815            foreach (analysisConfigSettings config in analysisCandidates)
     816            {
     817                pluginFacade.LogMessage(encrypt(config, preformatedText, config.PlugBoard), NotificationLevel.Debug);
     818            }
     819
     820            return encrypt(bestConfig, preformatedText, bestConfig.PlugBoard);
    813821        }
    814822
  • trunk/CrypPlugins/Enigma/EnigmaSettings.cs

    r353 r408  
    237237        private string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    238238
    239         private int maxSearchedPlugs = 10;
    240239        private bool analyzeRotors = true;
    241240        private bool analyzeKey = true;
     
    250249        private bool analysisUseRotorVII = true;
    251250        private bool analysisUseRotorVIII = true;
     251
     252        private int maxSearchedPlugs = 10;
     253        private int plugSearchMethod = 2;
    252254
    253255        private int rotor1 = 0;
     
    321323        #endregion
    322324
    323         #region Public Methods
    324 
    325        
     325        #region Public and Internal Methods
     326
     327        /// <summary>
     328        /// Return the expected length of n-grams statistics for the selected PlugSearchMethod.
     329        /// </summary>
     330        /// <returns></returns>
     331        internal int GetGramLength()
     332        {
     333            switch (plugSearchMethod)
     334            {
     335                case 0:
     336                    return 1;
     337                case 1:
     338                    return 2;
     339                case 2:
     340                    return 3;
     341                default:
     342                    return -1;
     343            }
     344        }
    326345
    327346        public void resetPlugBoard()
     
    745764        }
    746765
     766        [TaskPane("Plug search method", "Which method should be used to assess the best plugboard configuration?", "Analysis options", 9, false, DisplayLevel.Experienced, ControlType.ComboBox, new string[] { "Index of coincidence", "log2-bigram", "log2-trigram" })]
     767        public int PlugSearchMethod
     768        {
     769            get { return this.plugSearchMethod; }
     770            set
     771            {
     772                if (value != plugSearchMethod)
     773                {
     774                    hasChanges = true;
     775                    plugSearchMethod = value;
     776                    OnPropertyChanged("PlugSearchMethod");
     777                }
     778            }
     779        }
     780
    747781        #endregion
    748782
Note: See TracChangeset for help on using the changeset viewer.