source: trunk/CrypPlugins/Vernam/Vernam.cs @ 2424

Last change on this file since 2424 was 2334, checked in by Matthäus Wander, 11 years ago

removed 1006 occurences of DisplayLevel in 218 files (see #122)

File size: 9.2 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;
24using Cryptool.PluginBase.Cryptography;
25using Cryptool.PluginBase.IO;
26
27namespace Cryptool.Vernam
28{
29    [Author("Sebastian Przybylski", "sebastian@przybylski.org", "Uni-Siegen", "http://www.uni-siegen.de")]
30    [PluginInfo(false, "Vernam", "Vernam -- substitution cipher / stream cipher which is build by XORing the plaintext with a (pseudo) random stream of data to generate the ciphertext [One-time-Pad]", "Vernam/DetailedDescription/Description.xaml",
31      "Vernam/Images/icon.png", "Vernam/Images/encrypt.png", "Vernam/Images/decrypt.png")]
32    [EncryptionType(EncryptionType.Classic)]
33    public class Vernam : IEncryption
34    {
35        #region Private variables
36
37        private VernamSettings settings;
38        private CryptoolStream outputStream;
39        private byte[] inputKey;
40        private string inputString;
41        private string outputString;
42        private enum VernamMode { encrypt, decrypt };
43        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
44
45        #endregion
46
47        #region Public interface
48
49        /// <summary>
50        /// Contructor
51        /// </summary>
52        public Vernam()
53        {
54            this.settings = new VernamSettings();
55            ((VernamSettings)(this.settings)).LogMessage += Vernam_LogMessage;
56        }
57
58        /// <summary>
59        /// Get or set all settings for this algorithm
60        /// </summary>
61        public ISettings Settings
62        {
63            get { return (ISettings)this.settings; }
64            set { this.settings = (VernamSettings)value; }
65        }
66
67        [PropertyInfo(Direction.InputData, "Text input", "Input a string to be processed by the Vernam cipher", null, true, false,QuickWatchFormat.Text, null)]
68        public string InputString
69        {
70            get { return this.inputString; }
71            set
72            {
73                if (value != inputString)
74                {
75                    this.inputString = value;
76                    OnPropertyChanged("InputString");
77                }
78            }
79        }
80
81        [PropertyInfo(Direction.InputData, "Key", "Input key as byte array", null, true, false, QuickWatchFormat.Text, null)]
82        public byte[] InputKey
83        {
84            get { return this.inputKey; }
85            set
86            {
87                if (this.inputKey != value)
88                {
89                    this.inputKey = value;
90                }
91            }
92        }
93
94        [PropertyInfo(Direction.OutputData, "Stream output", "The string after processing with the Caesar cipher is converted to a stream. Default encoding is used.", null, false, false, QuickWatchFormat.Text, null)]
95        public CryptoolStream OutputStream
96        {
97            get
98            {
99                if (outputString != null)
100                {
101                    CryptoolStream cs = new CryptoolStream();
102                    listCryptoolStreamsOut.Add(cs);
103                    cs.OpenRead(this.GetPluginInfoAttribute().Caption,Encoding.Default.GetBytes(outputString.ToCharArray()));
104                    return cs;
105                }
106                else
107                {
108                    return null;
109                }
110            }
111            set { }
112        }
113
114        [PropertyInfo(Direction.OutputData, "Text output","The string after processing with the Vernam cipher", null, false, false,QuickWatchFormat.Text, null)]
115        public string OutputString
116        {
117            get { return this.outputString; }
118            set
119            {
120                this.outputString = value;
121                OnPropertyChanged("OutputString");
122            }
123        }
124
125
126        /// <summary>
127        /// Vernam encryption
128        /// </summary>
129        public void Encrypt()
130        {
131            ProcessVernam(VernamMode.encrypt);
132        }
133
134        /// <summary>
135        /// Vernam decryption
136        /// </summary>
137        public void Decrypt()
138        {
139            ProcessVernam(VernamMode.decrypt);
140        }
141
142        #endregion
143
144        #region IPlugin members
145
146        public void Initialize()
147        {
148        }
149
150        public void Dispose()
151        {
152            foreach (CryptoolStream stream in listCryptoolStreamsOut)
153            {
154                stream.Close();
155            }
156            listCryptoolStreamsOut.Clear();
157        }
158
159        public bool HasChanges
160        {
161            get { return settings.HasChanges; }
162            set { settings.HasChanges = value; }
163        }
164
165        /// <summary>
166        /// Fire if progress bar has to be updated
167        /// </summary>
168        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
169
170        /// <summary>
171        /// Fire, if new message has to be shown in the status bar
172        /// </summary>
173        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
174
175        public System.Windows.Controls.UserControl Presentation
176        {
177            get { return null; }
178        }
179
180        public System.Windows.Controls.UserControl QuickWatchPresentation
181        {
182            get { return null; }
183        }
184
185        public void Stop()
186        {
187        }
188
189        public void PostExecution()
190        {
191            Dispose();
192        }
193
194        public void PreExecution()
195        {
196            Dispose();
197        }
198
199        #endregion
200
201        #region INotifyPropertyChanged Members
202
203        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
204
205        public void OnPropertyChanged(string name)
206        {
207            if (PropertyChanged != null)
208            {
209                PropertyChanged(this, new PropertyChangedEventArgs(name));
210            }
211        }
212
213        #endregion
214
215
216
217        #region Private methods
218
219        private void ProcessVernam(VernamMode mode)
220        {
221            if (inputString != null && inputKey != null)
222            {
223                StringBuilder output = new StringBuilder(string.Empty);
224                inputKey = refillKey(inputKey, inputString.Length);
225
226                char cpos = '\0';
227                for (int i = 0; i < inputString.Length; i++)
228                {
229                    switch (mode)
230                    {
231                        case VernamMode.encrypt:
232                            cpos = (char)(inputString[i] ^ inputKey[i]);
233                            break;
234                        case VernamMode.decrypt:
235                            cpos = (char)(inputString[i] ^ inputKey[i]);
236                            break;
237                    }
238                    output.Append(Convert.ToString(cpos));
239
240                    //show the progress
241                    if (OnPluginProgressChanged != null)
242                    {
243                        OnPluginProgressChanged(this, new PluginProgressEventArgs(i, inputString.Length - 1));
244                    }
245                }
246                outputString = output.ToString();
247                OnPropertyChanged("OutputString");
248                OnPropertyChanged("OutputStream");
249               
250            }
251        }
252
253        private byte[] refillKey(byte[] key, int inputDataLength)
254        {
255          try
256          {
257            byte[] fullKey = new byte[inputDataLength];
258            for (int i = 0; i < inputDataLength; i++)
259              fullKey[i] = key[i % key.Length];
260            return fullKey;
261          }
262          catch (Exception ex)
263          {
264            Vernam_LogMessage(ex.Message, NotificationLevel.Error);           
265          }
266          return null;
267        }
268
269        void Vernam_LogMessage(string msg, NotificationLevel logLevel)
270        {
271            if (OnGuiLogNotificationOccured != null)
272            {
273                OnGuiLogNotificationOccured(this, new GuiLogEventArgs(msg, this, logLevel));
274            }
275        }
276
277        #endregion
278
279        #region IPlugin Members
280
281#pragma warning disable 67
282                                public event StatusChangedEventHandler OnPluginStatusChanged;
283#pragma warning restore
284
285        public void Execute()
286        {
287            switch (settings.Action)
288            {
289                case 0:
290                    Encrypt();
291                    break;
292                case 1:
293                    Decrypt();
294                    break;
295                default:
296                    break;
297            }
298        }
299
300        public void Pause()
301        {
302
303        }
304
305        #endregion
306    }
307}
Note: See TracBrowser for help on using the repository browser.