source: trunk/CrypPlugins/CubeAttack/CubeAttackSettings.cs @ 832

Last change on this file since 832 was 832, checked in by Sören Rinne, 12 years ago
  • slight changes in BerlekampMassey
  • changed CubeAttack, BooleanFunctionParser, Trivium to implement only one Controller interface (IControlGenerateBlackboxOutputBit)
  • modified samples
File size: 13.2 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.IO;
6using Cryptool.PluginBase;
7using System.ComponentModel;
8
9namespace Cryptool.CubeAttack
10{
11    public class CubeAttackSettings : ISettings
12    {
13        #region Public CubeAttack specific interface
14
15        /// <summary>
16        /// We use this delegate to send log messages from the settings class to the CubeAttack plugin
17        /// </summary>
18        /// <param name="sender"></param>
19        /// <param name="msg"></param>
20        /// <param name="logLevel"></param>
21        public delegate void CubeAttackLogMessage(string msg, NotificationLevel logLevel);
22
23        /// <summary>
24        /// Fire if a new message has to be shown in the status bar
25        /// </summary>
26        public event CubeAttackLogMessage LogMessage;
27       
28        /// <summary>
29        /// Returns true if some settigns have been changed. This value should be set
30        /// externally to false e.g. when a project was saved.
31        /// </summary>
32        [PropertySaveOrder(0)]
33        public bool HasChanges
34        {
35            get { return hasChanges; }
36            set { hasChanges = value; }
37        }
38
39        #endregion
40
41        #region Private variables
42
43        private bool hasChanges;
44        private int selectedBlackBox = 0;
45        private int selectedAction = 0;
46        private int publicVar;
47        private int secretVar;
48        private int maxcube;
49        private int constTest = 50;
50        private int linTest = 50;
51        private string setPublicBits = "0*00*";
52        private int outputBit;
53        private bool readSuperpolysFromFile;
54        private string openFilename;
55        private bool enableLogMessages = false;
56
57        private string saveOutputSuperpoly;
58        private Matrix saveSuperpolyMatrix;
59        private List<List<int>> saveListCubeIndexes;
60        private int[] saveOutputBitIndex;
61        private int saveCountSuperpoly;
62        private Matrix saveMatrixCheckLinearitySuperpolys;
63
64        #endregion
65
66
67        #region Algorithm settings properties (visible in the settings pane)
68
69        /*[PropertySaveOrder(1)]
70        [ContextMenu("Black Box",
71            "Select the black box",
72            1,
73            DisplayLevel.Beginner,
74            ContextMenuControlType.ComboBox,
75            null,
76            "Boolean function parser",
77            "Trivium")]
78        [TaskPane("Black Box",
79            "Select the black box",
80            "",
81            1,
82            false,
83            DisplayLevel.Beginner,
84            ControlType.ComboBox,
85            new string[] { "Boolean function parser", "Trivium" })]
86        public int BlackBox
87        {
88            get { return this.selectedBlackBox; }
89            set
90            {
91                if (value != selectedBlackBox) HasChanges = true;
92                this.selectedBlackBox = value;
93                OnPropertyChanged("BlackBox");
94            }
95        }*/
96
97        [PropertySaveOrder(2)]
98        [ContextMenu("Action",
99            "Select the cube attack modi",
100            2,
101            DisplayLevel.Beginner,
102            ContextMenuControlType.ComboBox,
103            null,
104            "Preprocessing",
105            "Online",
106            "Manual Public Bit Input")]
107        [TaskPane("Action",
108            "Select the cube attack modi",
109            "",
110            2,
111            false,
112            DisplayLevel.Beginner,
113            ControlType.ComboBox,
114            new string[] { "Preprocessing", "Online", "Manual Public Bit Input" })]
115        public int Action
116        {
117            get { return this.selectedAction; }
118            set
119            {
120                if(value != selectedAction) HasChanges = true;
121                this.selectedAction = value;
122                OnPropertyChanged("Action");
123            }
124        }
125       
126        [PropertySaveOrder(3)]
127        [TaskPane("Public Bit Size",
128            "Public input bits (IV or plaintext) of the attacked cryptosystem.",
129            null,
130            3,
131            false,
132            DisplayLevel.Beginner,
133            ControlType.NumericUpDown,
134            ValidationType.RangeInteger,
135            1,
136            10000)]
137        public int PublicVar
138        {
139            get { return publicVar; }
140            set
141            {
142                if (value != this.publicVar) HasChanges = true;
143                publicVar = value;
144                OnPropertyChanged("PublicVar");
145            }
146        }
147
148        [PropertySaveOrder(4)]
149        [TaskPane("Secret Bit Size",
150            "Key size or key length  of the attacked cryptosystem.",
151            null,
152            4,
153            false,
154            DisplayLevel.Beginner,
155            ControlType.NumericUpDown,
156            ValidationType.RangeInteger,
157            1,
158            10000)]
159        public int SecretVar
160        {
161            get { return secretVar; }
162            set
163            {
164                if (value != this.secretVar) HasChanges = true;
165                secretVar = value;
166                OnPropertyChanged("SecretVar");
167            }
168        }
169
170        [PropertySaveOrder(5)]
171        [TaskPane("Max Cube Size",
172            "Maxmium size of the summation cube.",
173            null,
174            5,
175            true,
176            DisplayLevel.Beginner,
177            ControlType.NumericUpDown,
178            ValidationType.RangeInteger,
179            1,
180            10000)]
181        public int MaxCube
182        {
183            get { return maxcube; }
184            set
185            {
186                if (value != this.maxcube) HasChanges = true;
187                maxcube = value;
188                OnPropertyChanged("MaxCube");
189            }
190        }
191
192        [PropertySaveOrder(6)]
193        [TaskPane("Constant Test",
194            "Number of tests to check if the superpoly is a constant value or not.",
195            null,
196            6,
197            true,
198            DisplayLevel.Beginner,
199            ControlType.NumericUpDown,
200            ValidationType.RangeInteger,
201            0,
202            100000)]
203        public int ConstTest
204        {
205            get { return constTest; }
206            set
207            {
208                if (value != this.constTest) HasChanges = true;
209                constTest = value;
210                OnPropertyChanged("ConstTest");
211            }
212        }
213
214        [PropertySaveOrder(7)]
215        [TaskPane("Linearity Test",
216            "Number of linearity tests to check if the superpoly is linear or not.",
217            null,
218            7,
219            true,
220            DisplayLevel.Beginner,
221            ControlType.NumericUpDown,
222            ValidationType.RangeInteger,
223            0,
224            100000)]
225        public int LinTest
226        {
227            get { return linTest; }
228            set
229            {
230                if (value != this.linTest) HasChanges = true;
231                linTest = value;
232                OnPropertyChanged("LinTest");
233            }
234        }
235
236        [PropertySaveOrder(8)]
237        [TaskPane("Output Bit",
238            "Chooses the output bit of the black box, which should be evaluated.",
239            null,
240            8,
241            true,
242            DisplayLevel.Beginner,
243            ControlType.NumericUpDown,
244            ValidationType.RangeInteger,
245            1,
246            10000)]
247        public int TriviumOutputBit
248        {
249            get { return outputBit; }
250            set
251            {
252                if (value != this.outputBit) HasChanges = true;
253                outputBit = value;
254                OnPropertyChanged("TriviumOutputBit");
255            }
256        }
257
258        [PropertySaveOrder(9)]
259        [TaskPane("Manual Public Bit Input",
260            "Possible inputs '0' (set bit to value 0), '1' (set bit to value 1) and '*' (sum the 0/1 value of the bit).",
261            null,
262            9,
263            false,
264            DisplayLevel.Beginner,
265            ControlType.TextBox,
266            null)]
267        public string SetPublicBits
268        {
269            get
270            {
271                if (setPublicBits != null)
272                    return setPublicBits;
273                else
274                    return "";
275            }
276            set
277            {
278                if (value != this.setPublicBits) HasChanges = true;
279                setPublicBits = value;
280                OnPropertyChanged("SetPublicBits");
281            }
282        }
283
284        [PropertySaveOrder(10)]
285        [ContextMenu("Read superpolys from File",
286            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
287            10,
288            DisplayLevel.Experienced,
289            ContextMenuControlType.CheckBox,
290            null,
291            new string[] { "Read superpolys from File" })]
292        [TaskPane("Read superpolys from File",
293            "With this checkbox enabled, superpolys will be loaded from the selected File and can be evaluated in the online phase.",
294            null,
295            10,
296            false,
297            DisplayLevel.Beginner,
298            ControlType.CheckBox,
299            "",
300            null)]
301        public bool ReadSuperpolysFromFile
302        {
303            get { return this.readSuperpolysFromFile; }
304            set
305            {
306                this.readSuperpolysFromFile = (bool)value;
307                OnPropertyChanged("ReadSuperpolysFromFile");
308                HasChanges = true;
309            }
310        }
311
312        [PropertySaveOrder(11)]
313        [TaskPane("Filename", "Select the file you want to open.",
314            null,
315            11,
316            false,
317            DisplayLevel.Beginner,
318            ControlType.OpenFileDialog,
319            FileExtension = "All Files (*.*)|*.*")]
320        public string OpenFilename
321        {
322            get { return openFilename; }
323            set
324            {
325                if (value != openFilename)
326                {
327                    openFilename = value;
328                    HasChanges = true;
329                    OnPropertyChanged("OpenFilename");
330                }
331            }
332        }
333
334        [PropertySaveOrder(12)]
335        [ContextMenu("Enable log messages",
336            "With this checkbox enabled, log messages will be showed.",
337            12,
338            DisplayLevel.Experienced,
339            ContextMenuControlType.CheckBox,
340            null,
341            new string[] { "Enable log messages?" })]
342        [TaskPane("Enable log messages",
343            "With this checkbox enabled, a lot of log messages will be showed during preprocessing.",
344            null,
345            12,
346            false,
347            DisplayLevel.Beginner,
348            ControlType.CheckBox,
349            "",
350            null)]
351        public bool EnableLogMessages
352        {
353            get { return this.enableLogMessages; }
354            set
355            {
356                this.enableLogMessages = (bool)value;
357                OnPropertyChanged("EnableLogMessages");
358                HasChanges = true;
359            }
360        }
361
362        public string SaveOutputSuperpoly
363        {
364            get { return saveOutputSuperpoly; }
365            set
366            {
367                if (value != saveOutputSuperpoly) hasChanges = true;
368                saveOutputSuperpoly = value;
369            }
370        }
371
372        public Matrix SaveSuperpolyMatrix
373        {
374            get { return saveSuperpolyMatrix; }
375            set
376            {
377                if (value != saveSuperpolyMatrix) hasChanges = true;
378                saveSuperpolyMatrix = value;
379            }
380        }
381
382        public List<List<int>> SaveListCubeIndexes
383        {
384            get { return saveListCubeIndexes; }
385            set
386            {
387                if (value != saveListCubeIndexes) hasChanges = true;
388                saveListCubeIndexes = value;
389            }
390        }
391
392        public int[] SaveOutputBitIndex
393        {
394            get { return saveOutputBitIndex; }
395            set
396            {
397                if (value != saveOutputBitIndex) hasChanges = true;
398                saveOutputBitIndex = value;
399            }
400        }
401
402        public int SaveCountSuperpoly
403        {
404            get { return saveCountSuperpoly; }
405            set
406            {
407                if (value != saveCountSuperpoly) hasChanges = true;
408                saveCountSuperpoly = value;
409            }
410        }
411
412        public Matrix SaveMatrixCheckLinearitySuperpolys
413        {
414            get { return saveMatrixCheckLinearitySuperpolys; }
415            set
416            {
417                if (value != saveMatrixCheckLinearitySuperpolys) hasChanges = true;
418                saveMatrixCheckLinearitySuperpolys = value;
419            }
420        }
421
422        #endregion
423
424
425        #region INotifyPropertyChanged Members
426
427        public event PropertyChangedEventHandler PropertyChanged;
428
429        protected void OnPropertyChanged(string name)
430        {
431            if (PropertyChanged != null)
432            {
433                PropertyChanged(this, new PropertyChangedEventArgs(name));
434            }
435        }
436
437        #endregion
438    }
439}
Note: See TracBrowser for help on using the repository browser.