source: trunk/CrypPlugins/Playfair/PlayfairSettings.cs @ 1778

Last change on this file since 1778 was 1256, checked in by Matthäus Wander, 12 years ago

Playfair:

  • fixed preformatting to be consistent with literature (e.g. William Stallings: Cryptography and Network Security (page 44); F. L. Bauer: Entzifferte Geheimnisse (page 66))
  • closes #133
  • fixed another issue (last character insertion)
File size: 11.6 KB
Line 
1/*
2   Copyright 2008 Sebastian Przybylski, University of Siegen
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;
22using System.IO;
23using System.ComponentModel;
24
25namespace Cryptool.Playfair
26{
27    public class PlayfairSettings : ISettings
28    {
29        #region Public Playfair specific interface
30
31        /// <summary>
32        /// We use this delegate to send log messages from the settings class to the Playfair plugin
33        /// </summary>
34        /// <param name="msg"></param>
35        /// <param name="logLevel"></param>
36        public delegate void PlayfairLogMessage(string msg, NotificationLevel logLevel);
37
38        /// <summary>
39        /// Fire, if a new message has to be shown in the status bar
40        /// </summary>
41        public event PlayfairLogMessage LogMessage;
42
43        [PropertySaveOrder(1)]
44        public bool HasChanges
45        {
46            get { return hasChanges; }
47            set { hasChanges = value; }
48        }
49
50        #endregion
51
52        #region Private variables
53
54        private bool hasChanges;
55        private bool seperatePairs = true;
56        private int selectedAction = 0;
57        private bool preFormatText = true;
58        private bool ignoreDuplicates = true;
59        private int matrixSize = 0; //0=5x5, 1=6x6
60        private string smallAlphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ";
61        private string largeAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
62        private string alphabetMatrix = "ABCDEFGHIKLMNOPQRSTUVWXYZ";
63        private string alphPool;
64        private string key;
65        private char separator = 'X';
66        private char separatorReplacement = 'Y';
67
68        #endregion
69
70        #region Algorithm settings properties (visible in the Settings pane)
71
72        [PropertySaveOrder(2)]
73        [ContextMenu("Action","Select the Algorithm action",1,DisplayLevel.Beginner,ContextMenuControlType.ComboBox, new int[] {1,2}, "Encrypt","Decrypt")]
74        [TaskPane("Action","Select the Algorithm action",null,1,false,DisplayLevel.Beginner,ControlType.ComboBox, new string[] {"Encrypt","Decrypt"})]
75        public int Action
76        {
77            get { return this.selectedAction; }
78            set
79            {
80                if (value != selectedAction) HasChanges = true;
81                this.selectedAction = value;
82                OnPropertyChanged("Action");
83            }
84        }
85
86        [PropertySaveOrder(3)]
87        [TaskPane("Key value (multiple letters)","Enter one or multiple key values",null,2,false,DisplayLevel.Beginner,ControlType.TextBox,null)]
88        public string Key
89        {
90            get 
91            {
92              if (key != null)
93                return key.ToUpper();
94              else
95                return null;
96            }
97            set
98            {
99                if (value.ToUpper() != key) HasChanges = true;
100                this.key = value.ToUpper();
101                setKeyMatrix();
102                OnPropertyChanged("Key");
103                OnPropertyChanged("AlphabetMatrix");
104            }
105        }
106
107        [PropertySaveOrder(4)]
108        [TaskPane("Alphabet", "This is the used alphabet cipher to encrypt/decrypt.", null, 3, false, DisplayLevel.Expert, ControlType.TextBox, "")]
109        public string AlphabetMatrix
110        {
111            get { return this.alphabetMatrix; }
112            set
113            {
114                if (value != this.alphabetMatrix) HasChanges = true;
115                this.alphabetMatrix = value;
116                OnPropertyChanged("AlphabetMatrix");
117            }
118        }
119
120        [PropertySaveOrder(5)]
121        [ContextMenu("Pre-Format-Text","This is used to determine whether the text should be confinded to the alphabet used.",4,DisplayLevel.Beginner,ContextMenuControlType.CheckBox,null,"Pre-format text")]
122        [TaskPane("Pre-Format-Text","This is used to determine whether the text should be confinded to the alphabet used.",null,4,false,DisplayLevel.Expert,ControlType.CheckBox,"")]
123        public bool PreFormatText
124        {
125            get { return this.preFormatText; }
126            set
127            {
128                if (value != this.preFormatText) HasChanges = true;
129                this.preFormatText = value;
130                OnPropertyChanged("PreFormatText");
131            }
132        }
133
134        [PropertySaveOrder(6)]
135        [ContextMenu("Ignore duplicates","Ignore duplicates within the key phrase",5,DisplayLevel.Beginner,ContextMenuControlType.CheckBox,null,"Ignore duplicates within the key phrase")]
136        [TaskPane("Ignore duplicates","Ignore duplicates within the key phrase",null,5,false,DisplayLevel.Expert,ControlType.CheckBox,"")]
137        public bool IgnoreDuplicates
138        {
139            get { return this.ignoreDuplicates; }
140            set
141            {
142                if (value != this.ignoreDuplicates) HasChanges = true;
143                this.ignoreDuplicates = value;
144                OnPropertyChanged("IgnoreDuplicates");
145                setKeyMatrix();
146            }
147        }
148
149        [PropertySaveOrder(7)]
150        [ContextMenu("Matrix size","Select whether the Playfair should be run with a 5x5 or 6x6 matrix",6,DisplayLevel.Expert,ContextMenuControlType.ComboBox,null,new string[]{"5 x 5","6 x 6"})]
151        [TaskPane("Matrix size", "Select whether the Playfair should be run with a 5x5 or 6x6 matrix", null, 6,false, DisplayLevel.Expert, ControlType.ComboBox, "5 x 5","6 x 6")]
152        public int MatrixSize
153        {
154            get { return this.matrixSize; }
155            set 
156            {
157                if (value != this.matrixSize) HasChanges = true;
158                this.matrixSize = value;
159                setKeyMatrix();
160                OnPropertyChanged("MatrixSize");
161            }
162        }
163
164        [PropertySaveOrder(8)]
165        [ContextMenu("Separate pairs", "Seperate pairs of identical letters", 7, DisplayLevel.Expert, ContextMenuControlType.CheckBox, null, "Separate pairs of identical letters")]
166        [TaskPane("Separate pairs", "Separate pairs of identical letters", null, 7, false, DisplayLevel.Expert, ControlType.CheckBox, "")]
167        public bool SeperatePairs
168        {
169            get { return this.seperatePairs; }
170            set
171            {
172                if (value != this.seperatePairs) HasChanges = true;
173                this.seperatePairs = value;
174                OnPropertyChanged("SeperatePairs");
175            }
176        }
177
178        [PropertySaveOrder(9)]       
179        [TaskPane("Separator","Enter the character to separate pairs of identical letters",null,8,false,DisplayLevel.Expert, ControlType.TextBox,"")]
180        public char Separator
181        {
182            get { return char.ToUpper(this.separator); }
183            set 
184            {
185                if (char.ToUpper(value) != this.separator) HasChanges = true;
186                this.separator = char.ToUpper(value);
187                setSeparatorReplacement();
188                OnPropertyChanged("Separator");
189                OnPropertyChanged("SeparatorReplacement");
190            }
191        }
192
193        [PropertySaveOrder(10)]
194        [TaskPane("Separator replacement", "Enter the character to separate double separators.\nE.g. a double XX will be separate by insertion of Y", null, 9, false, DisplayLevel.Expert, ControlType.TextBox, "")]
195        public char SeparatorReplacement
196        {
197            get { return char.ToUpper(this.separatorReplacement);}
198            set
199            {
200                if (char.ToUpper(value) != this.separatorReplacement) HasChanges = true;
201                this.separatorReplacement = char.ToUpper(value);
202                setSeparator();
203                OnPropertyChanged("Separator");
204                OnPropertyChanged("SeparatorReplacement");
205            }
206        }
207
208
209
210
211        #endregion
212
213        #region Private Members
214
215        private string removeEqualChars(string value)
216        {
217            int length = value.Length;
218
219            for (int i = 0; i < length; i++)
220            {
221                for (int j = i + 1; j < length; j++)
222                {
223                    if (value[i] == value[j])
224                    {
225                        value = value.Remove(j, 1);
226                        j--;
227                        length--;
228                    }
229                }
230            }
231            return value;
232        }
233
234        private string getKey()
235        {
236            string tempKey = string.Empty;
237
238            for (int i = 0; i < key.Length; i++)
239            {
240                char cPos = key[i];
241                if (tempKey.Contains(cPos))
242                {
243                    cPos = getNextChar(cPos);
244                }
245                tempKey += cPos.ToString();
246            }
247            return tempKey;
248        }
249
250        private char getNextChar(char value)
251        {
252            for (int i = 0; i < alphPool.Length; i++)
253            {
254                if (alphPool.IndexOf(alphPool[i]) > alphPool.IndexOf(value) && !key.Contains(alphPool[i]))
255                {
256                    value = alphPool[i];
257                    alphPool = alphPool.Remove(i, 1);
258                    break;
259                }
260            }
261            return value;
262        }
263
264        private void setKeyMatrix()
265        {
266            string tempKey = key;
267
268            string tempAlph = string.Empty;
269
270            switch (matrixSize)
271            {
272                case 0:
273                    tempAlph = smallAlphabet;
274                    break;
275                case 1:
276                    tempAlph = largeAlphabet;
277                    break;
278                default:
279                    break;
280            }
281
282            if (!ignoreDuplicates)
283            {
284                alphPool = tempAlph;
285                tempKey = getKey();
286            }
287
288            AlphabetMatrix = removeEqualChars(tempKey + tempAlph);
289        }
290
291        private void setSeparator()
292        {
293            if (this.separator == this.separatorReplacement)
294            {
295                int separatorReplacementPos = AlphabetMatrix.IndexOf(this.separatorReplacement);
296                int separatorPos = (separatorReplacementPos - 1 + AlphabetMatrix.Length) % AlphabetMatrix.Length;
297                this.separator = AlphabetMatrix[separatorPos];
298            }
299        }
300
301        private void setSeparatorReplacement()
302        {
303            if (this.separator == this.separatorReplacement)
304            {
305                int separatorPos = AlphabetMatrix.IndexOf(this.separator);
306                int separatorReplacementPos = (separatorPos + 1) % AlphabetMatrix.Length;
307                this.separatorReplacement = AlphabetMatrix[separatorReplacementPos];
308            }
309        }
310
311        #endregion
312
313        #region INotifyPropertyChanged Members
314
315        public event PropertyChangedEventHandler PropertyChanged;
316
317        protected void OnPropertyChanged(string name)
318        {
319            if (PropertyChanged != null)
320            {
321                PropertyChanged(this, new PropertyChangedEventArgs(name));
322            }
323        }
324
325        #endregion
326    }
327}
Note: See TracBrowser for help on using the repository browser.