source: trunk/CrypPlugins/CaesarAnalysisHelper/CaesarAnalysisHelper.cs @ 1378

Last change on this file since 1378 was 899, checked in by enkler, 12 years ago

added license and copyright
disabled warnings

File size: 9.6 KB
Line 
1/*                             
2   Copyright 2009 Fabian Enkler
3
4   Licensed under the Apache License, Version 2.0 (the "License");
5   you may not use this file except in compliance with the License.
6   You may obtain a copy of the License at
7
8       http://www.apache.org/licenses/LICENSE-2.0
9
10   Unless required by applicable law or agreed to in writing, software
11   distributed under the License is distributed on an "AS IS" BASIS,
12   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   See the License for the specific language governing permissions and
14   limitations under the License.
15*/
16
17using System;
18using System.ComponentModel;
19using System.Linq;
20using System.Windows.Controls;
21using Cryptool.PluginBase;
22using System.Collections.Generic;
23using Cryptool.PluginBase.Analysis;
24
25namespace Cryptool.CaesarAnalysisHelper
26{
27    [Author("Fabian Enkler", "enkler@cryptool.org", "", "")]
28    [PluginInfo(false, "CaesarAnalysisHelper", "This plugin is designed in order to make a cryptanalysis of a caesarcipher based on the frequency test.", "", "CaesarAnalysisHelper/icon.png")]
29    public class CaesarAnalysisHelper : ISpecific
30    {
31        private readonly CaesarAnalysisHelperSettings settings;
32
33        public event PropertyChangedEventHandler PropertyChanged;
34#pragma warning disable 67
35        public event StatusChangedEventHandler OnPluginStatusChanged;
36        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
37        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
38#pragma warning restore
39
40        public CaesarAnalysisHelper()
41        {
42            this.settings = new CaesarAnalysisHelperSettings();
43        }
44
45        public ISettings Settings
46        {
47            get { return settings; }
48        }
49
50        private string encryptedText;
51        [PropertyInfo(Direction.InputData, "Encrypted text", "The caesar encrpyted text", null, false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
52        public string EncryptedText
53        {
54            get { return encryptedText; }
55            set
56            {
57                encryptedText = value;
58                OnPropertyChanged("EncryptedText");
59            }
60        }
61
62        private string frequencyList = string.Empty;
63        [PropertyInfo(Direction.InputData, "Frequency List", "This is the analysis input from the frequency test.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text,
64            null)]
65        public string FrequencyList
66        {
67            get { return frequencyList; }
68            set
69            {
70                frequencyList = value;
71                OnPropertyChanged("FrequencyList");
72            }
73        }
74
75        private int key;
76        [PropertyInfo(Direction.OutputData, "Key", "This is the estimated key.", "", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
77        public int Key
78        {
79            get
80            {
81                return key;
82            }
83        }
84
85        private void CryptoAnalysis()
86        {
87            var KeyList = new Dictionary<int, int>();
88            int Counter = 0;
89            foreach (var i in CountChars(frequencyList.ToLower()))
90            {
91                if (Counter < 5)
92                {
93                    if (!KeyList.ContainsKey(i))
94                        KeyList.Add(i, 5 - Counter);
95                    else
96                    {
97                        KeyList[i] += 5 - Counter;
98                    }
99                    Counter++;
100                }
101            }
102
103            Counter = 0;
104            foreach (var i in CountBigrams(encryptedText.ToLower()))
105            {
106                if (Counter < 5)
107                {
108                    if (!KeyList.ContainsKey(i))
109                        KeyList.Add(i, 5 - Counter);
110                    else
111                    {
112                        KeyList[i] += 5 - Counter;
113                    }
114                    Counter++;
115                }
116            }
117
118            var items = (from k in KeyList.Keys
119                         orderby KeyList[k] descending
120                         select k);
121            var ResultList = new List<int>();
122            foreach (var i in items)
123            {
124                ResultList.Add(i);
125            }
126            if (ResultList.Count > 0)
127            {
128                key = ResultList[0];
129                OnPropertyChanged("Key");
130            }
131        }
132
133        private List<int> CountChars(string text)
134        {
135            var Dic = new Dictionary<char, int>();
136
137            if (!string.IsNullOrEmpty(text))
138            {
139                foreach (var s in text.Split(new[] { "\r\n" }, StringSplitOptions.None))
140                {
141                    if (!string.IsNullOrEmpty(s))
142                    {
143                        string[] tmpArr = s.Split(new[] { ':' });
144                        if (tmpArr.Length > 1)
145                        {
146
147                            char c = tmpArr[0][0];
148                            int Count;
149                            int.TryParse(tmpArr[1], out Count);
150                            if (!Dic.ContainsKey(c))
151                                Dic.Add(c, 0);
152                            Dic[c] += Count;
153                        }
154                    }
155                }
156
157                var items = (from k in Dic.Keys
158                             orderby Dic[k] descending
159                             select k);
160
161                var Result = new List<int>();
162                foreach (var c in items)
163                {
164                    int tmp = c - settings.FrequentChar;
165                    int temp = 26 + tmp;
166                    if (tmp < 0)
167                        Result.Add(temp);   
168                    if (tmp > 0)
169                        Result.Add(tmp);
170                    if (tmp == 0)
171                        Result.Add(tmp);
172                       
173                   
174                }
175                return Result;
176            }
177            return new List<int>();
178        }
179
180        private static List<int> CountBigrams(string text)
181        {
182            if (!string.IsNullOrEmpty(text))
183            {
184
185                var BigramDic = new Dictionary<string, int>();
186                for (int i = 0; i < text.Length - 1; i++)
187                {
188                    string tmp = text.Substring(i, 2);
189                    if (!tmp.Contains(" "))
190                    {
191                        if (!BigramDic.ContainsKey(tmp))
192                            BigramDic.Add(tmp, 0);
193                        BigramDic[tmp]++;
194                    }
195                }
196
197                var items = (from k in BigramDic.Keys
198                             orderby BigramDic[k] descending
199                             select k);
200
201                var Bigrams = new[] { "er", "en", "ch", "de" };
202                var KeyList = new Dictionary<int, int>();
203                foreach (var s in items)
204                {
205                    int Counter = 0;
206                    string CurrentBigramm;
207                    do
208                    {
209                        if (Counter < Bigrams.Length)
210                            CurrentBigramm = Bigrams[Counter];
211                        else
212                        {
213                            CurrentBigramm = string.Empty;
214                            break;
215                        }
216                        Counter++;
217                    } while (!(CurrentBigramm[1] - CurrentBigramm[0] == s[1] - s[0]));
218
219                    if (!String.IsNullOrEmpty(CurrentBigramm))
220                    {
221                        int tmpkey = s[0] - CurrentBigramm[0];
222                        if (!KeyList.ContainsKey(tmpkey))
223                            KeyList.Add(tmpkey, 0);
224                        KeyList[tmpkey]++;
225                    }
226                }
227                var items2 = (from k in KeyList.Keys
228                              orderby KeyList[k] descending
229                              select k);
230                var Result = new List<int>();
231                foreach (var s in items2)
232                {
233                    Result.Add(s);
234                }
235
236                return Result;
237            }
238            return new List<int>();
239        }
240
241        public UserControl Presentation
242        {
243            get { return null; }
244        }
245
246        public UserControl QuickWatchPresentation
247        {
248            get { return null; }
249        }
250
251        public void PreExecution()
252        {
253            encryptedText = string.Empty;
254            key = 0;
255            frequencyList = string.Empty;
256        }
257
258        public void Execute()
259        {
260            CryptoAnalysis();
261        }
262
263        public void PostExecution()
264        {
265
266        }
267
268        public void Pause()
269        {
270
271        }
272
273        public void Stop()
274        {
275
276        }
277
278        public void Initialize()
279        {
280
281        }
282
283        public void Dispose()
284        {
285
286        }
287
288        private void OnPropertyChanged(string name)
289        {
290            if (PropertyChanged != null)
291            {
292                PropertyChanged(this, new PropertyChangedEventArgs(name));
293            }
294        }
295
296/*
297        private void GuiNotification(string text)
298        {
299            GuiNotification(text, NotificationLevel.Debug);
300        }
301*/
302
303/*
304        private void GuiNotification(string text, NotificationLevel Level)
305        {
306            if (OnGuiLogNotificationOccured != null)
307                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(text, this, Level));
308        }
309*/
310    }
311}
Note: See TracBrowser for help on using the repository browser.