source: trunk/CrypPlugins/CostFunction/CostFunction.cs @ 717

Last change on this file since 717 was 717, checked in by Sven Rech, 12 years ago

some KeySearcher changes

File size: 12.3 KB
Line 
1/*                             
2   Copyright 2009 Team CrypTool (Sven Rech,Dennis Nolte,Raoul Falk,Nils Kopal), Uni Duisburg-Essen
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.Collections.Generic;
19using System.Linq;
20using System.Text;
21using Cryptool.PluginBase.Cryptography;
22using Cryptool.PluginBase;
23using Cryptool.PluginBase.Miscellaneous;
24using Cryptool.PluginBase.Analysis;
25using System.ComponentModel;
26using Cryptool.PluginBase.Control;
27
28namespace Cryptool.Plugins.CostFunction
29{
30    [Author("Nils Kopal", "Nils.Kopal@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
31    [PluginInfo(false, "CostFunction", "CostFunction", null, "CostFunction/icon.png")]
32    public class CostFunction : IAnalysisMisc
33    {
34        #region private variables
35        private CostFunctionSettings settings = new CostFunctionSettings();
36        private byte[] inputText = null;
37        private byte[] outputText = null;
38        private double value = 0;
39        private Boolean stopped = true;
40        private IControlCost controlSlave;
41        #endregion
42
43        #region CostFunctionInOut       
44
45        [PropertyInfo(Direction.InputData, "Text Input", "Input your Text here", "", DisplayLevel.Beginner)]
46        public byte[] InputText
47        {
48            get
49            {
50                return inputText;
51            }
52            set
53            {
54                this.inputText = value;               
55                OnPropertyChanged("InputText");
56            }
57        }
58
59        [PropertyInfo(Direction.OutputData, "Text Output", "Your Text will be send here", "", DisplayLevel.Beginner)]
60        public byte[] OutputText
61        {
62            get
63            {
64                return outputText;
65            }
66            set
67            {
68                this.outputText = value;               
69                OnPropertyChanged("OutputText");
70            }
71        }
72
73        [PropertyInfo(Direction.OutputData, "Value", "The value of the function wull be send here", "", DisplayLevel.Beginner)]
74        public double Value
75        {
76            get
77            {
78                return value;
79            }
80            set
81            {
82                this.value = value;
83                OnPropertyChanged("Value");
84            }
85        }
86               
87        [PropertyInfo(Direction.ControlSlave, "SDES Slave", "Direct access to SDES.", "", DisplayLevel.Beginner)]
88        public IControlCost ControlSlave
89        {
90            get
91            {
92                if (controlSlave == null)
93                    controlSlave = new CostFunctionControl(this);
94                return controlSlave;
95            }
96        } 
97
98        #endregion
99
100        #region IPlugin Members
101
102        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
103        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
104       
105
106        public ISettings Settings
107        {
108            get { return this.settings; }
109            set { this.settings = (CostFunctionSettings)value; }
110        }
111
112        public System.Windows.Controls.UserControl Presentation
113        {
114            get { return null; }
115        }
116
117        public System.Windows.Controls.UserControl QuickWatchPresentation
118        {
119            get { return null; }
120        }
121
122        public void PreExecution()
123        {
124            this.stopped = false;
125        }
126
127        public void Execute()
128        {
129            if (this.InputText is Object && this.stopped == false)
130            {
131                int blocksize = 0;
132                try
133                {
134                    blocksize = int.Parse(settings.Blocksize);
135                }
136                catch (Exception ex)
137                {
138                    GuiLogMessage("Entered blocksize is not an integer: " + ex.Message, NotificationLevel.Error);
139                    return;
140                }
141                byte[] array;
142
143                if (blocksize > 0)
144                {
145                    //Create a new Array of size of Blocksize if needed
146                    array = new byte[blocksize];
147                    for (int i = 0; i < blocksize && i < this.InputText.Length; i++)
148                    {
149                        array[i] = InputText[i];
150                    }
151                }
152                else
153                {
154                    array = this.InputText;
155                }
156
157                ProgressChanged(0.5, 1); 
158
159                switch (settings.FunctionType)
160                {
161
162                    case 0: // Index of Coincedence
163                        this.Value = calculateIndexOfCoincidence(array);
164                        break;
165
166                    case 1: // Entropy
167                        this.Value = calculateEntropy(array);
168                        break;
169
170                    default:
171                        this.Value = -1;
172                        break;
173                }//end switch               
174 
175                this.OutputText = this.InputText;
176                ProgressChanged(1, 1);   
177
178            }//end if
179           
180        }//end Execute
181
182        public void PostExecution()
183        {
184            this.stopped = true;
185        }
186
187        public void Pause()
188        {
189           
190        }
191
192        public void Stop()
193        {
194            this.stopped = false;
195        }
196
197        public void Initialize()
198        {
199
200        }
201
202        public void Dispose()
203        {
204           
205        }
206
207        #endregion     
208
209        #region INotifyPropertyChanged Members
210
211        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
212
213        public void OnPropertyChanged(string name)
214        {
215            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
216        }
217
218        private void ProgressChanged(double value, double max)
219        {
220            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
221        }
222
223        public void GuiLogMessage(string p, NotificationLevel notificationLevel)
224        {
225            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(p, this, notificationLevel));
226        }
227
228        #endregion
229
230        #region IPlugin Members
231
232        public event StatusChangedEventHandler OnPluginStatusChanged;
233
234        #endregion
235
236        #region private methods
237
238        /// <summary>
239        /// Calculates the Index of Coincidence multiplied with 100 of
240        /// a given byte array
241        ///
242        /// for example a German text has about 7.62
243        ///           an English text has about 6.61
244        /// </summary>
245        /// <param name="text">text to use</param>
246        /// <returns>Index of Coincidence</returns>
247        public double calculateIndexOfCoincidence(byte[] text)
248        {
249
250            double[] n = new double[256];
251            //count all ASCII symbols
252            foreach (byte b in text)
253            {
254                    n[b]++;
255            }
256
257            double coindex = 0;
258            //sum them
259            for (int i = 0; i < n.Length; i++)
260            {
261                coindex = coindex + n[i] * (n[i] - 1);               
262            }
263
264            coindex = coindex / (text.Length);
265            coindex = coindex / (text.Length - 1);
266
267            return coindex * 100;
268
269        }//end calculateIndexOfCoincidence
270
271        /// <summary>
272        /// Calculates the Entropy of a given byte array
273        /// for example a German text has about 4.0629
274        /// </summary>
275        /// <param name="text">text to use</param>
276        /// <returns>Entropy</returns>
277        public double calculateEntropy(byte[] text)
278        {
279
280            double[] n = new double[256];
281            //count all ASCII symbols
282            foreach (byte b in text)
283            {
284                    n[b]++;
285            }
286
287            double entropy = 0;
288            //calculate probabilities and sum entropy
289            for (int i = 0; i < n.Length; i++)
290            {
291                double pz = n[i] / text.Length; //probability of character n[i]
292                if (pz > 0)
293                    entropy = entropy + pz * Math.Log(pz, 2);
294            }
295
296            return -1 * entropy; // because of log we have negative values, but we want positive
297
298        }//end calculateEntropy
299
300        #endregion
301
302     
303    }
304
305    #region slave
306
307    public class CostFunctionControl : IControlCost
308    {
309        public event IControlStatusChangedEventHandler OnStatusChanged;
310        #region IControlCost Members
311
312        private CostFunction plugin;
313
314        #endregion
315
316        /// <summary>
317        /// Constructor
318        /// </summary>
319        /// <param name="plugin"></param>
320        public CostFunctionControl(CostFunction plugin)
321        {
322            this.plugin = plugin;
323        }
324
325        public int getBlocksize()
326        {
327            try
328            {
329                return int.Parse(((CostFunctionSettings)this.plugin.Settings).Blocksize);
330            }
331            catch (Exception ex)
332            {
333                throw new Exception("Entered blocksize is not an integer: " + ex.Message);
334            }
335        }
336
337        /// <summary>
338        /// Returns the relation operator of the cost function which is set by by CostFunctionSettings
339        /// </summary>
340        /// <returns>RelationOperator</returns>
341        public RelationOperator getRelationOperator()
342        {
343            switch (((CostFunctionSettings)this.plugin.Settings).FunctionType)
344            {
345                case 0: //Index of coincidence
346                    return RelationOperator.LargerThen;
347                case 1: //Entropy
348                    return RelationOperator.LessThen;
349                default:
350                    throw new NotImplementedException("The value " + ((CostFunctionSettings)this.plugin.Settings).FunctionType + " is not implemented.");
351            }//end switch
352        }//end getRelationOperator
353
354        /// <summary>
355        /// Calculates the cost function of the given text
356        ///
357        /// Cost function can be set by CostFunctionSettings
358        /// This algorithm uses a blocksize which can be set by CostFunctionSettings
359        /// If blocksize is set to 0 it uses the whole text
360        ///
361        /// </summary>
362        /// <param name="text"></param>
363        /// <returns>cost</returns>
364        public double calculateCost(byte[] text)
365        {
366            int blocksize = 0;
367            try
368            {
369                blocksize = int.Parse(((CostFunctionSettings)this.plugin.Settings).Blocksize);
370            }
371            catch (Exception ex)
372            {
373                throw new Exception("Entered blocksize is not an integer: " + ex.Message);
374            }
375            byte[] array;
376
377            if (blocksize > 0)
378            {
379                //Create a new Array of size of Blocksize if needed
380                array = new byte[blocksize];
381                for (int i = 0; i < blocksize && i < text.Length; i++)
382                {
383                    array[i] = text[i];
384                }
385            }
386            else
387            {
388                array = text;
389            }
390
391            switch (((CostFunctionSettings)this.plugin.Settings).FunctionType)
392            {
393                case 0: //Index of coincidence
394                    return plugin.calculateIndexOfCoincidence(array);
395                case 1: //Entropy
396                    return plugin.calculateEntropy(array);
397                default:
398                    throw new NotImplementedException("The value " + ((CostFunctionSettings)this.plugin.Settings).FunctionType + " is not implemented.");
399            }//end switch
400        }
401
402        #endregion
403    }
404   
405}
Note: See TracBrowser for help on using the repository browser.