Ignore:
Timestamp:
Mar 15, 2009, 5:14:32 PM (13 years ago)
Author:
enkler
Message:

Added language support to CaesarAnalysisHelper
Added bigram support to CaesarAnalysisHelper

Location:
trunk/CrypPlugins/CaesarAnalysisHelper
Files:
2 edited

Legend:

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

    r240 r243  
    11using System;
    22using System.ComponentModel;
     3using System.Linq;
    34using System.Windows.Controls;
    45using Cryptool.PluginBase;
    56using Cryptool.PluginBase.IO;
     7using System.Collections.Generic;
    68
    79namespace Cryptool.CaesarAnalysisHelper
     
    1820    {
    1921        private readonly CaesarAnalysisHelperSettings settings;
    20         private string inputList = string.Empty;
    21         private int key;
    2222
    2323        public event PropertyChangedEventHandler PropertyChanged;
     
    3434        {
    3535            get { return settings; }
    36         }
    37 
    38         [PropertyInfo(Direction.Input, "List Input", "This is the analysis input from the frequency test.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text,
     36        }
     37
     38        private string frequencyList = string.Empty;
     39        [PropertyInfo(Direction.Input, "Frequency List", "This is the analysis input from the frequency test.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text,
    3940            null)]
    40         public string InputList
    41         {
    42             get { return inputList; }
    43             set
    44             {
    45                 inputList = value;
    46                 OnPropertyChanged("InputList");
    47                 ProcessList();
    48             }
    49         }
    50 
     41        public string FrequencyList
     42        {
     43            get { return frequencyList; }
     44            set
     45            {
     46                frequencyList = value;
     47                OnPropertyChanged("FrequencyList");
     48            }
     49        }
     50
     51        private string encryptedText;
     52        [PropertyInfo(Direction.Input, "Encrypted text", "The caesar encrpyted text", null, false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     53        public string EncryptedText
     54        {
     55            get { return encryptedText; }
     56            set
     57            {
     58                encryptedText = value;
     59                OnPropertyChanged("EncryptedText");
     60            }
     61        }
     62
     63        /*private string dictionary;
     64        [PropertyInfo(Direction.Input, "Dictionary", "Dictionary for Bruteforce attack", null, false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
     65        public string Dictionary
     66        {
     67            get { return dictionary; }
     68            set
     69            {
     70                dictionary = value;
     71                OnPropertyChanged("Dictionary");
     72            }
     73        }
     74
     75        private string bruteForceDecryptedText;
     76        [PropertyInfo(Direction.Input, "Bruteforce decrypted text", "This the text, which was decrypted by the caesar plugin.", null, false, false, DisplayLevel.Professional, QuickWatchFormat.Text, null)]
     77        public string BruteForceDecryptedText
     78        {
     79            get { return bruteForceDecryptedText; }
     80            set
     81            {
     82                bruteForceDecryptedText = value;
     83                OnPropertyChanged("BruteForceDecryptedText");
     84            }
     85        }
     86
     87        private string bruteForceEncryptedText;
     88        [PropertyInfo(Direction.Output, "Bruteforce encrypted text", "This the text, which should be encrypted by the caesar plugin with bruteforce.", null, false, false, DisplayLevel.Professional, QuickWatchFormat.Text, null)]
     89        public string BruteForceEnCryptedText
     90        {
     91            get { return bruteForceEncryptedText; }
     92            set
     93            {
     94                bruteForceEncryptedText = value;
     95                OnPropertyChanged("BruteForceEncryptedText");
     96            }
     97        }
     98
     99        private int bruteForceKeyOutput;
     100        [PropertyInfo(Direction.Output, "Bruteforce key", "This key should be connected to the caesar bruteforce plugin.", null, false, false, DisplayLevel.Professional, QuickWatchFormat.Text, null)]
     101        public int BruteForceKeyOutput
     102        {
     103            get { return bruteForceKeyOutput; }
     104            set
     105            {
     106                bruteForceKeyOutput = value;
     107                OnPropertyChanged("BruteForceKeyOutput");
     108            }
     109        }*/
     110
     111        private int key;
    51112        [PropertyInfo(Direction.Output, "Key", "This is the estimated key.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
    52113        public int Key
     
    58119        }
    59120
    60         private void ProcessList()
    61         {
    62             GuiNotification(inputList);
    63             if (!string.IsNullOrEmpty(inputList))
    64             {
    65                 try
    66                 {
    67                     int HighestCount = 0;
    68                     foreach (var s in inputList.Split(new[] { "\r\n" }, StringSplitOptions.None))
     121        public void CryptoAnalysis()
     122        {
     123            var KeyList = new Dictionary<int, int>();
     124            int Counter = 0;
     125            foreach (var i in CountChars(frequencyList))
     126            {
     127                if (Counter < 5)
     128                {
     129                    if (!KeyList.ContainsKey(i))
     130                        KeyList.Add(i, 5 - Counter);
     131                    else
     132                    {
     133                        KeyList[i] += 5 - Counter;
     134                    }
     135                    Counter++;
     136                }
     137            }
     138
     139            Counter = 0;
     140            foreach (var i in CountBigrams2(encryptedText))
     141            {
     142                if (Counter < 5)
     143                {
     144                    if (!KeyList.ContainsKey(i))
     145                        KeyList.Add(i, 5 - Counter);
     146                    else
     147                    {
     148                        KeyList[i] += 5 - Counter;
     149                    }
     150                    Counter++;
     151                }
     152            }
     153
     154            var items = (from k in KeyList.Keys
     155                         orderby KeyList[k] descending
     156                         select k);
     157            var ResultList = new List<int>();
     158            foreach (var i in items)
     159            {
     160                ResultList.Add(i);
     161            }
     162            if (ResultList.Count > 0)
     163            {
     164                key = ResultList[0];
     165                OnPropertyChanged("Key");
     166            }
     167        }
     168
     169        private List<int> CountChars(string text)
     170        {
     171            var Dic = new Dictionary<char, int>();
     172
     173            if (!string.IsNullOrEmpty(text))
     174            {
     175                foreach (var s in text.Split(new[] { "\r\n" }, StringSplitOptions.None))
     176                {
     177                    if (!string.IsNullOrEmpty(s))
    69178                    {
    70179                        string[] tmpArr = s.Split(new[] { ':' });
    71180                        if (tmpArr.Length > 0)
    72181                        {
     182
     183                            char c = tmpArr[0][0];
    73184                            int Count;
    74185                            int.TryParse(tmpArr[1], out Count);
    75                             if (Count > HighestCount)
    76                             {
    77                                 HighestCount = Count;
    78                                 key = tmpArr[0][0]-settings.FrequentChar;
    79                                 GuiNotification(string.Format("New highest count: {0}", tmpArr[0][0]));
    80                             }
     186                            if (!Dic.ContainsKey(c))
     187                                Dic.Add(c, 0);
     188                            Dic[c] += Count;
    81189                        }
    82190                    }
    83191                }
    84                 catch (Exception)
    85                 {
    86 
    87                     GuiNotification("Wrong input format!");
    88                 }
    89                
    90             }
    91             OnPropertyChanged("Key");
    92         }
     192
     193                var items = (from k in Dic.Keys
     194                             orderby Dic[k] descending
     195                             select k);
     196
     197                var Result = new List<int>();
     198                foreach (var c in items)
     199                {
     200                    int tmp = c - settings.FrequentChar;
     201                    if (tmp > 0)
     202                        Result.Add(tmp);
     203                }
     204                return Result;
     205            }
     206            return new List<int>();
     207        }
     208
     209        private List<int> CountBigrams2(string text)
     210        {
     211            if (!string.IsNullOrEmpty(text))
     212            {
     213
     214                var BigramDic = new Dictionary<string, int>();
     215                for (int i = 0; i < text.Length - 1; i++)
     216                {
     217                    string tmp = text.Substring(i, 2);
     218                    if (!tmp.Contains(" "))
     219                    {
     220                        if (!BigramDic.ContainsKey(tmp))
     221                            BigramDic.Add(tmp, 0);
     222                        BigramDic[tmp]++;
     223                    }
     224                }
     225
     226                var items = (from k in BigramDic.Keys
     227                             orderby BigramDic[k] descending
     228                             select k);
     229
     230                var Bigrams = new[] { "er", "en", "ch", "de" };
     231                var KeyList = new Dictionary<int, int>();
     232                foreach (var s in items)
     233                {
     234                    int Counter = 0;
     235                    string CurrentBigramm;
     236                    do
     237                    {
     238                        if (Counter < Bigrams.Length)
     239                            CurrentBigramm = Bigrams[Counter];
     240                        else
     241                        {
     242                            CurrentBigramm = string.Empty;
     243                            break;
     244                        }
     245                        Counter++;
     246                    } while (!(CurrentBigramm[1] - CurrentBigramm[0] == s[1] - s[0]));
     247
     248                    if (!String.IsNullOrEmpty(CurrentBigramm))
     249                    {
     250                        int tmpkey = s[0] - CurrentBigramm[0];
     251                        if (!KeyList.ContainsKey(tmpkey))
     252                            KeyList.Add(tmpkey, 0);
     253                        KeyList[tmpkey]++;
     254                    }
     255                }
     256                var items2 = (from k in KeyList.Keys
     257                              orderby KeyList[k] descending
     258                              select k);
     259                var Result = new List<int>();
     260                foreach (var s in items2)
     261                {
     262                    Result.Add(s);
     263                }
     264
     265                return Result;
     266            }
     267            return new List<int>();
     268        }
     269
     270        private List<int> CountBigrams(string text)
     271        {
     272            if (!string.IsNullOrEmpty(text))
     273            {
     274                var BigramList = new List<string>();
     275
     276                for (int i = 0; i < text.Length - 1; i++)
     277                {
     278                    string tmp = text.Substring(i, 2);
     279                    BigramList.Add(tmp);
     280                }
     281                var Result = new List<int>();
     282                var KeyList = new Dictionary<int, int>();
     283                foreach (var c in BigramList)
     284                {
     285                    int Distance = c[0] - c[1];
     286                    if (Distance < 0)
     287                        Distance = c[1] - c[0];
     288                    int tmpKey;
     289                    switch (Distance)
     290                    {
     291                        case 'n' - 'e':
     292                            tmpKey = c[0] - 'e';
     293                            if (c[0] - 'e' == c[1] - 'n')
     294                            {
     295                                if (!KeyList.ContainsKey(tmpKey))
     296                                    KeyList.Add(tmpKey, 0);
     297                                KeyList[tmpKey]++;
     298                            }
     299                            break;
     300                        case 'r' - 'e':
     301                            tmpKey = c[0] - 'e';
     302                            if (c[0] - 'e' == c[1] - 'r')
     303                            {
     304                                if (!KeyList.ContainsKey(tmpKey))
     305                                    KeyList.Add(tmpKey, 0);
     306                                KeyList[tmpKey]++;
     307                            }
     308                            break;
     309                        case 'h' - 'c':
     310                            tmpKey = c[0] - 'c';
     311                            if (c[0] - 'c' == c[1] - 'h')
     312                            {
     313                                if (!KeyList.ContainsKey(tmpKey))
     314                                    KeyList.Add(tmpKey, 0);
     315                                KeyList[tmpKey]++;
     316                            }
     317                            break;
     318                        case 'i' - 'e':
     319                            if (c[0] < c[1])
     320                            {
     321                                tmpKey = c[0] - 'e';
     322                                if (c[0] - 'e' == c[1] - 'i')
     323                                {
     324                                    if (!KeyList.ContainsKey(tmpKey))
     325                                        KeyList.Add(tmpKey, 0);
     326                                    KeyList[tmpKey]++;
     327                                }
     328                            }
     329                            else
     330                            {
     331                                tmpKey = c[0] - 'i';
     332                                if (c[0] - 'i' == c[1] - 'e')
     333                                {
     334                                    if (!KeyList.ContainsKey(tmpKey))
     335                                        KeyList.Add(tmpKey, 0);
     336                                    KeyList[tmpKey]++;
     337                                }
     338                            }
     339
     340                            break;
     341                        case 't' - 'e':
     342                            tmpKey = c[0] - 't';
     343                            if (c[0] - 't' == c[1] - 'e')
     344                            {
     345                                if (!KeyList.ContainsKey(tmpKey))
     346                                    KeyList.Add(tmpKey, 0);
     347                                KeyList[tmpKey]++;
     348                            }
     349                            break;
     350                        case 'e' - 'd':
     351                            tmpKey = c[0] - 'd';
     352                            if (c[0] - 'd' == c[1] - 'e')
     353                            {
     354                                if (!KeyList.ContainsKey(tmpKey))
     355                                    KeyList.Add(tmpKey, 0);
     356                                KeyList[tmpKey]++;
     357                            }
     358                            break;
     359                    }
     360                }
     361
     362                var items2 = (from k in KeyList.Keys
     363                              orderby KeyList[k] descending
     364                              select k);
     365                foreach (var s in items2)
     366                {
     367                    Result.Add(s);
     368                }
     369
     370                return Result;
     371            }
     372            return new List<int>();
     373        }
     374
     375
     376
     377
     378
     379
    93380
    94381        public UserControl Presentation
     
    104391        public void PreExecution()
    105392        {
    106 
     393            encryptedText = string.Empty;
     394            key = 0;
     395            frequencyList = string.Empty;
    107396        }
    108397
    109398        public void Execute()
    110399        {
    111 
     400            CryptoAnalysis();
    112401        }
    113402
     
    147436        private void GuiNotification(string text)
    148437        {
    149             GuiNotification(text,NotificationLevel.Debug);
     438            GuiNotification(text, NotificationLevel.Debug);
    150439        }
    151440
  • trunk/CrypPlugins/CaesarAnalysisHelper/CaesarAnalysisHelperSettings.cs

    r240 r243  
     1using System;
    12using Cryptool.PluginBase;
    23using System.ComponentModel;
     
    45namespace Cryptool.CaesarAnalysisHelper
    56{
     7    public enum Language
     8    {
     9        German,
     10        English,
     11        French,
     12        Spanish
     13    }
     14
    615    class CaesarAnalysisHelperSettings : ISettings
    716    {
    8         private char frequentChar = 'e';
     17        internal char FrequentChar = 'e';
    918
    10         [PropertySaveOrder(0)]
    11         [TaskPane("Frequent Char", "The most frequent char in the text's language.", null, 4, false, DisplayLevel.Beginner, ControlType.TextBox, ValidationType.RegEx, "^([a-z]){1,1}$")]
    12         public char FrequentChar
     19        private Language Lang = Language.German;
     20
     21        [TaskPane("Language", "The text's language.", null, 0, false, DisplayLevel.Beginner, ControlType.ComboBox, new[] { "German", "English", "French", "Spanish" })]
     22        public string TextLanguage
    1323        {
    14             get { return frequentChar; }
     24            get
     25            {
     26                return Lang.ToString();
     27            }
    1528            set
    1629            {
    17                 frequentChar = value;
    18                 if (PropertyChanged != null)
    19                     PropertyChanged(this, new PropertyChangedEventArgs("FrequentChar"));
     30                try
     31                {
     32                    Lang = (Language)Enum.Parse(typeof(Language), value);
     33                    OnPropertyChanged("Language");
     34                    switch (Lang)
     35                    {
     36                        case Language.German:
     37                        case Language.English:
     38                        case Language.French:
     39                        case Language.Spanish:
     40                            FrequentChar = 'e';
     41                            break;
     42                        default:
     43                            break;
     44                    }
     45                }
     46                catch (Exception)
     47                {
     48                }
    2049            }
    2150        }
    2251
    23         [PropertySaveOrder(1)]
     52        private bool hasChanges;
    2453        public bool HasChanges
    2554        {
    26             get;
    27             set;
     55            get { return hasChanges; }
     56            set
     57            {
     58                if (value != hasChanges)
     59                {
     60                    hasChanges = value;
     61                    OnPropertyChanged("HasChanges");
     62                }
     63            }
    2864        }
    2965
    3066        public event PropertyChangedEventHandler PropertyChanged;
     67
     68        private void OnPropertyChanged(string name)
     69        {
     70            if (PropertyChanged != null)
     71                PropertyChanged(this, new PropertyChangedEventArgs(name));
     72            if (name.ToLower() != "haschanges")
     73                HasChanges = true;
     74        }
    3175    }
    3276}
Note: See TracChangeset for help on using the changeset viewer.