source: trunk/CrypPlugins/DES/DES.cs @ 1121

Last change on this file since 1121 was 1121, checked in by kohnen, 12 years ago
  • deleted setInput-function from IControlEncryption and all Plugins using IControlEncryption
  • some changes at TranspositionAnalyser plugin & Settings
  • new TranspositionAnalyser sample
File size: 30.2 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.IO;
6using System.Security.Cryptography;
7using Cryptool.PluginBase;
8using System.ComponentModel;
9using Cryptool.PluginBase.Cryptography;
10using Cryptool.PluginBase.IO;
11using System.Windows.Controls;
12using Cryptool.PluginBase.Control;
13using System.Reflection;
14// Reference to the CubeAttackController interface (own dll)
15using Cryptool.CubeAttackController;
16
17namespace Cryptool.Plugins.Cryptography.Encryption
18{
19    [PluginInfo(false, "DES", "Data Encryption Standard", "DES/DetailedDescription/Description.xaml", "DES/icon.png", "DES/Images/encrypt.png", "DES/Images/decrypt.png")]
20    [EncryptionType(EncryptionType.SymmetricBlock)]
21    public class DES : IEncryption
22    {
23        #region Private variables
24        private DESSettings settings;
25        private CryptoolStream inputStream;
26        private CryptoolStream outputStream;
27        private List<CryptoolStream> listCryptoolStreamsOut = new List<CryptoolStream>();
28        private byte[] inputKey;
29        private byte[] inputIV;
30        private CryptoStream p_crypto_stream;
31        private bool stop = false;
32        private IControlEncryption controlSlave;
33        #endregion
34
35        public DES()
36        {
37            this.settings = new DESSettings();
38            this.settings.OnPluginStatusChanged += settings_OnPluginStatusChanged;
39        }
40
41        void settings_OnPluginStatusChanged(IPlugin sender, StatusEventArgs args)
42        {
43            if(OnPluginStatusChanged != null)OnPluginStatusChanged(this, args);
44        }
45
46        public ISettings Settings
47        {
48            get { return this.settings; }
49            set { this.settings = (DESSettings)value; }
50        }
51
52        [PropertyInfo(Direction.InputData, "Input", "Data to be encrypted or decrypted", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
53        public CryptoolStream InputStream
54        {
55            get 
56            {
57                if (inputStream != null)
58                {
59                    CryptoolStream cs = new CryptoolStream();
60                    cs.OpenRead(inputStream.FileName);
61                    listCryptoolStreamsOut.Add(cs);
62                    return cs;
63                }
64                else return null;
65            }
66            set 
67            { 
68              this.inputStream = value;
69              if (value != null) listCryptoolStreamsOut.Add(value);
70              OnPropertyChanged("InputStream");
71            }
72        }
73
74        [PropertyInfo(Direction.InputData, "Key", "Must be 8 bytes.", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
75        public byte[] InputKey
76        {
77            get { return this.inputKey; }
78            set
79            {
80                this.inputKey = value;
81                OnPropertyChanged("InputKey");
82            }
83        }
84
85        [PropertyInfo(Direction.InputData, "IV", "IV to be used in chaining modes, must be the same as the Blocksize in bytes (8 bytes).", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
86        public byte[] InputIV
87        {
88            get { return this.inputIV; }
89            set
90            {
91                this.inputIV = value;
92                OnPropertyChanged("InputIV");
93            }
94        }
95       
96        [PropertyInfo(Direction.OutputData, "Output stream", "Encrypted or decrypted output data", null, true, false, DisplayLevel.Beginner, QuickWatchFormat.Hex, null)]
97        public CryptoolStream OutputStream
98        {
99            get
100            {
101                if (this.outputStream != null)
102                {
103                    CryptoolStream cs = new CryptoolStream();
104                    listCryptoolStreamsOut.Add(cs);
105                    cs.OpenRead(this.outputStream.FileName);
106                    return cs;
107                }
108                return null;
109            }
110            set
111            {
112                outputStream = value;
113                if (value != null) listCryptoolStreamsOut.Add(value);
114                OnPropertyChanged("OutputStream");
115            }
116        }
117
118        private void ConfigureAlg(SymmetricAlgorithm alg)
119        {
120            //check for a valid key
121            if (this.inputKey == null)
122            {
123                //create a trivial key
124                inputKey = new byte[8];
125                // write a warning to the ouside word
126                GuiLogMessage("WARNING - No key provided. Using 0x000..00!", NotificationLevel.Warning);
127            }
128            alg.Key = this.inputKey;
129
130            //check for a valid IV
131            if (this.inputIV == null)
132            {
133                //create a trivial key
134                inputIV = new byte[alg.BlockSize / 8];
135               GuiLogMessage("WARNING - No IV provided. Using 0x000..00!", NotificationLevel.Warning);
136            }
137            alg.IV = this.inputIV;
138            switch (settings.Mode)
139            { //0="ECB"=default, 1="CBC", 2="CFB", 3="OFB"
140                case 1: alg.Mode = CipherMode.CBC; break;
141                case 2: alg.Mode = CipherMode.CFB; break;
142                case 3: alg.Mode = CipherMode.OFB; break;
143                default: alg.Mode = CipherMode.ECB; break;
144            }
145            switch (settings.Padding)
146            { //0="Zeros"=default, 1="None", 2="PKCS7"
147                case 1: alg.Padding = PaddingMode.None; break;
148                case 2: alg.Padding = PaddingMode.PKCS7; break;
149                case 3: alg.Padding = PaddingMode.ANSIX923; break;
150                case 4: alg.Padding = PaddingMode.ISO10126; break;
151                default: alg.Padding = PaddingMode.Zeros; break;
152            }
153        }
154
155        private void checkForInputStream()
156        {
157            if (settings.Action == 0 && (inputStream == null || (inputStream != null && inputStream.Length == 0)))
158            {
159                //create some input
160                String dummystring = "Dummy string - no input provided - \"Hello DES World\" - dummy string - no input provided!";
161                this.inputStream = new CryptoolStream();
162                this.inputStream.OpenRead(this.GetPluginInfoAttribute().Caption, Encoding.Default.GetBytes(dummystring.ToCharArray()));
163                // write a warning to the ouside word
164                GuiLogMessage("WARNING - No input provided. Using dummy data. (" + dummystring + ")", NotificationLevel.Warning);
165            }
166        }
167
168        public void Execute()
169        {
170            try
171            {
172                //copy inputStream for Slave
173                if (controlSlave is object && InputStream is object && InputIV is object)
174                {
175                    CryptoolStream cs = new CryptoolStream();
176                    cs.OpenRead(inputStream.FileName); 
177                    ((DESControl)controlSlave).InputStream = cs;
178                }
179
180                process(settings.Action);
181
182                //Work with slave
183                if (controlSlave is object && InputStream is object && InputIV is object)
184                {
185                    ((DESControl)controlSlave).reset();
186                    ((DESControl)controlSlave).onStatusChanged();
187
188                }
189            }
190            finally
191            {
192                if (controlSlave is object && ((DESControl)controlSlave).InputStream is object)
193                    ((DESControl)controlSlave).closeStreams();
194            }
195        }
196
197        private void process(int action)
198        {
199            //Encrypt/Decrypt Stream
200            try
201            {
202                checkForInputStream();
203                if (inputStream == null || (inputStream != null && inputStream.Length == 0))
204                {
205                    GuiLogMessage("No input given. Not using dummy data in decrypt mode. Aborting now.", NotificationLevel.Error);
206                    return;
207                }
208
209                if (this.inputStream.CanSeek) this.inputStream.Position = 0;
210                SymmetricAlgorithm p_alg = new DESCryptoServiceProvider();
211
212                ConfigureAlg(p_alg);
213
214                ICryptoTransform p_encryptor = null;
215                switch (action)
216                {
217                    case 0:
218                        p_encryptor = p_alg.CreateEncryptor();
219                        break;
220                    case 1:
221                        p_encryptor = p_alg.CreateDecryptor();
222                        break;
223                }
224
225                outputStream = new CryptoolStream();
226                listCryptoolStreamsOut.Add(outputStream);
227                outputStream.OpenWrite(this.GetPluginInfoAttribute().Caption);
228                p_crypto_stream = new CryptoStream((Stream)inputStream, p_encryptor, CryptoStreamMode.Read);
229                byte[] buffer = new byte[p_alg.BlockSize / 8];
230                int bytesRead;
231                int position = 0;
232                GuiLogMessage("Starting encryption [Keysize=" + p_alg.KeySize.ToString() + " Bits, Blocksize=" + p_alg.BlockSize.ToString() + " Bits]", NotificationLevel.Info);
233                DateTime startTime = DateTime.Now;
234                while ((bytesRead = p_crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !stop)
235                {
236                    outputStream.Write(buffer, 0, bytesRead);
237
238                    if ((int)(inputStream.Position * 100 / inputStream.Length) > position)
239                    {
240                        position = (int)(inputStream.Position * 100 / inputStream.Length);
241                        ProgressChanged(inputStream.Position, inputStream.Length);
242                    }
243                }
244
245                p_crypto_stream.Flush();
246                outputStream.Close();
247                DateTime stopTime = DateTime.Now;
248                TimeSpan duration = stopTime - startTime;
249                if (!stop)
250                {
251                    GuiLogMessage("Encryption complete! (in: " + inputStream.Length.ToString() + " bytes, out: " + outputStream.Length.ToString() + " bytes)", NotificationLevel.Info);
252                    GuiLogMessage("Wrote data to file: " + outputStream.FileName, NotificationLevel.Info);
253                    GuiLogMessage("Time used: " + duration.ToString(), NotificationLevel.Debug);
254                    OnPropertyChanged("OutputStream");
255                }
256                if (stop)
257                {
258                    GuiLogMessage("Aborted!", NotificationLevel.Info);
259                }
260            }
261            catch (CryptographicException cryptographicException)
262            {
263                p_crypto_stream = null;
264                GuiLogMessage(cryptographicException.Message, NotificationLevel.Error);
265            }
266            catch (Exception exception)
267            {
268                GuiLogMessage(exception.Message, NotificationLevel.Error);
269            }
270            finally
271            {
272                ProgressChanged(1, 1);
273            }
274        }
275
276        public void Encrypt()
277        {
278            //Encrypt Stream
279            process(0);
280        }
281
282        public void Decrypt()
283        {
284            //Decrypt Stream
285            process(1);
286        }
287
288        #region IPlugin Member
289
290        public UserControl Presentation
291        {
292            get { return null; }
293        }
294
295        public UserControl QuickWatchPresentation
296        {
297          get { return null; }
298        }
299
300        public void Initialize()
301        {
302        }
303
304        public void Dispose()
305        {
306            try
307            {
308                stop = false;
309                inputKey = null;
310                inputIV = null;
311
312                inputStream = null;
313                outputStream = null;
314
315                foreach (CryptoolStream stream in listCryptoolStreamsOut)
316                {
317                    stream.Close();
318                }
319                listCryptoolStreamsOut.Clear();
320
321                if (p_crypto_stream != null)
322                {
323                    p_crypto_stream.Flush();
324                    p_crypto_stream.Close();
325                    p_crypto_stream = null;
326                }
327            }
328            catch (Exception ex)
329            {
330                GuiLogMessage(ex.Message, NotificationLevel.Error);
331            }
332            this.stop = false;
333        }
334
335        public void Stop()
336        {
337            this.stop = true;
338        }
339
340        public bool isStopped(){
341
342            return this.stop;
343        }
344
345        public void PostExecution()
346        {
347            Dispose();
348        }
349
350        public void PreExecution()
351        {
352            Dispose();
353        }
354
355        #endregion
356
357        #region INotifyPropertyChanged Members
358
359        public event PropertyChangedEventHandler PropertyChanged;
360
361        public void OnPropertyChanged(string name)
362        {
363            if (PropertyChanged != null)
364            {
365                PropertyChanged(this, new PropertyChangedEventArgs(name));
366            }
367        }
368
369        #endregion
370
371        #region IPlugin Members
372
373        public event StatusChangedEventHandler OnPluginStatusChanged;
374
375        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
376        public void GuiLogMessage(string message, NotificationLevel logLevel)
377        {
378          if (OnGuiLogNotificationOccured != null)
379          {
380            OnGuiLogNotificationOccured(this, new GuiLogEventArgs(message, this, logLevel));
381          }
382        }
383
384        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
385        private void ProgressChanged(double value, double max)
386        {
387          if (OnPluginProgressChanged != null)
388          {
389            OnPluginProgressChanged(this, new PluginProgressEventArgs(value, max));
390          }
391        }
392
393        public void Pause()
394        {
395         
396        }
397
398        #endregion
399
400        [PropertyInfo(Direction.ControlSlave, "DES Slave", "Direct access to DES.", "", DisplayLevel.Beginner)]
401        public IControlEncryption ControlSlave
402        {
403          get
404          {
405              if (controlSlave == null)
406                  controlSlave = new DESControl(this);
407              return controlSlave;
408          }
409        }
410
411        private IControlCubeAttack desSlave;
412        [PropertyInfo(Direction.ControlSlave, "DES for cube attack", "Direct access to DES.", "", DisplayLevel.Beginner)]
413        public IControlCubeAttack DESSlave
414        {
415            get
416            {
417                if (desSlave == null)
418                    desSlave = new CubeAttackControl(this);
419                return desSlave;
420            }
421        }
422    }
423
424    #region DESControl : IControlCubeAttack
425
426    public class CubeAttackControl : IControlCubeAttack
427    {
428        public event IControlStatusChangedEventHandler OnStatusChanged;
429        private DES plugin;
430
431        public CubeAttackControl(DES Plugin)
432        {
433            this.plugin = Plugin;
434        }
435
436        #region IControlEncryption Members
437
438        public int GenerateBlackboxOutputBit(object IV, object key, object length)
439        {
440            // public bits := plaintext
441            // secret bits := key
442            SymmetricAlgorithm p_alg = new DESCryptoServiceProvider();
443            string secretBits = string.Empty;
444            string publicBits = string.Empty;
445
446            // save public and secret bits as string
447            int[] temp = key as int[];
448            for (int i = 0; i < temp.Length; i++)
449                secretBits += temp[i];
450            temp = IV as int[];
451            for (int i = 0; i < temp.Length; i++)
452                publicBits += temp[i];
453
454            // convert secret bits to byte array
455            int[] arrInt = new int[8];
456            for (int i = 0; i < 8; i++)
457            {
458                for (int j = 0; j < 8; j++)
459                {
460                    if (secretBits[(8 * i) + j] == '1')
461                        arrInt[i] += (int)Math.Pow(2, 7 - j);
462                }
463            }
464            byte[] keyByte = new byte[8];
465            for (int i = 0; i < arrInt.Length; i++)
466                keyByte[i] = (byte)arrInt[i];
467
468            // convert public bits to byte array
469            arrInt = new int[8];
470            for (int i = 0; i < 8; i++)
471            {
472                for (int j = 0; j < 8; j++)
473                {
474                    if (publicBits[(8 * i) + j] == '1')
475                        arrInt[i] += (int)Math.Pow(2, 7 - j);
476                }
477            }
478            byte[] publicByte = new byte[8];
479            for (int i = 0; i < arrInt.Length; i++)
480                publicByte[i] = (byte)arrInt[i];
481
482            ICryptoTransform p_encryptor;
483            p_alg.IV = new byte[8];
484            p_alg.Padding = PaddingMode.Zeros;
485            try
486            {
487                p_alg.Key = keyByte;
488            }
489            catch
490            {
491                //dirty hack to allow weak keys:
492                FieldInfo field = p_alg.GetType().GetField("KeyValue", BindingFlags.NonPublic | BindingFlags.Instance);
493                field.SetValue(p_alg, keyByte);
494            }
495            try
496            {
497                p_encryptor = p_alg.CreateEncryptor();
498            }
499            catch
500            {
501                //dirty hack to allow weak keys:
502                MethodInfo mi = p_alg.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
503                object[] Par = { p_alg.Key, p_alg.Mode, p_alg.IV, p_alg.FeedbackSize, 0 };
504                p_encryptor = mi.Invoke(p_alg, Par) as ICryptoTransform;
505            }
506           
507            Stream inputPublic = new MemoryStream(publicByte);
508            // starting encryption
509            CryptoStream p_crypto_stream = new CryptoStream(inputPublic, p_encryptor, CryptoStreamMode.Read);
510            byte[] buffer = new byte[p_alg.BlockSize / 8];
511            p_crypto_stream.Read(buffer, 0, buffer.Length);
512               
513            // convert encrypted block to binary string
514            string strBytes = string.Empty;
515            for (int i = 0; i < buffer.Length; i++)
516            {
517                for (int j = 7; j >= 0; j--)
518                    strBytes += (buffer[i] & 1 << j) > 0 ? 1 : 0;
519            }
520            p_crypto_stream.Flush();
521
522            // return single output bit
523            return Int32.Parse(strBytes.Substring((int)length-1, 1));
524        }
525        #endregion
526    }
527
528    #endregion
529
530    public class DESControl : IControlEncryption
531    {
532        public event KeyPatternChanged keyPatternChanged;
533        public event IControlStatusChangedEventHandler OnStatusChanged;
534        private DES plugin;
535        private SymmetricAlgorithm des_algorithm = null;
536        private byte[] input;
537        private Stream inputStream;
538 
539        public CryptoolStream InputStream{
540            get;set;
541        }
542
543        public void reset()
544        {
545            input = null;
546            des_algorithm = null;
547        }
548
549        public void closeStreams()
550        {
551            if (inputStream != null)
552                inputStream.Close();
553            if (InputStream != null)
554                InputStream.Close();
555        }
556
557        public DESControl(DES Plugin)
558        {
559            this.plugin = Plugin;
560        }
561
562        #region IControlEncryption Members
563
564        public byte[] Encrypt(byte[] key, int blocksize)
565        {
566            /// not implemented, currently not needed
567            throw new NotImplementedException();
568        }
569
570        // TODO: add override with iv, mode, blocksize
571        public byte[] Decrypt(byte[] ciphertext, byte[] key)
572        {
573            CryptoStream crypto_stream = null;
574            byte[] output = new byte[8];
575           
576            // always recreating this instance is thread-safe, but may cost us some performance
577            SymmetricAlgorithm des_algorithm  = new DESCryptoServiceProvider();
578
579            // TODO: this should be configurable via method signature
580            des_algorithm.Mode = CipherMode.ECB;
581            des_algorithm.Padding = PaddingMode.PKCS7;
582
583            try
584            {
585                des_algorithm.Key = key;
586            }
587            catch
588            {
589                //dirty hack to allow weak keys:
590                FieldInfo field = des_algorithm.GetType().GetField("KeyValue", BindingFlags.NonPublic | BindingFlags.Instance);
591                Console.WriteLine(des_algorithm.GetType());
592                field.SetValue(des_algorithm, key);
593            }
594
595            ICryptoTransform p_decryptor;
596            try
597            {
598                p_decryptor = des_algorithm.CreateDecryptor();
599            }
600            catch
601            {
602                //dirty hack to allow weak keys:
603                MethodInfo mi = des_algorithm.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
604                object[] Par = { des_algorithm.Key, des_algorithm.Mode, des_algorithm.IV, des_algorithm.FeedbackSize, 0 };
605                p_decryptor = mi.Invoke(des_algorithm, Par) as ICryptoTransform;
606            }
607
608            crypto_stream = new CryptoStream(new MemoryStream(ciphertext, false), p_decryptor, CryptoStreamMode.Read);
609
610            int read, readOverall = 0;
611            do
612            {
613                read = crypto_stream.Read(output, readOverall, output.Length - readOverall);
614                readOverall += read;
615            } while (read > 0 && readOverall < output.Length);
616
617            return output;
618
619            //try
620            //{
621            //    des_algorithm.IV = this.plugin.InputIV;
622            //}
623            //catch
624            //{
625            //    //dirty hack to allow weak keys:
626            //    FieldInfo field = des_algorithm.GetType().GetField("IVValue", BindingFlags.NonPublic | BindingFlags.Instance);
627            //    field.SetValue(des_algorithm, this.plugin.InputIV);
628            //}
629
630            //switch (((DESSettings)plugin.Settings).Mode)
631            //{ //0="ECB"=default, 1="CBC", 2="CFB", 3="OFB"
632            //    case 1: alg.Mode = CipherMode.CBC; break;
633            //    case 2: alg.Mode = CipherMode.CFB; break;
634            //    case 3: alg.Mode = CipherMode.OFB; break;
635            //    default: alg.Mode = CipherMode.ECB; break;
636            //}
637            //switch (((DESSettings)plugin.Settings).Padding)
638            //{ //0="Zeros"=default, 1="None", 2="PKCS7"
639            //    case 1: alg.Padding = PaddingMode.None; break;
640            //    case 2: alg.Padding = PaddingMode.PKCS7; break;
641            //    case 3: alg.Padding = PaddingMode.ANSIX923; break;
642            //    case 4: alg.Padding = PaddingMode.ISO10126; break;
643            //    default: alg.Padding = PaddingMode.Zeros; break;
644            //}
645        }
646
647        [Obsolete("this signature doesn't pass the ciphertext, use Decrypt(byte[], byte[]) instead")]
648        public byte[] Decrypt(byte[] key, int blocksize)
649        {
650            int size = (int)this.InputStream.Length;
651
652            if (blocksize < size)
653                size = blocksize;
654
655            if (!(this.input is object))
656            {
657                input = new byte[size];
658                this.InputStream.Seek(0, 0);
659                for (int i = 0; i < size && i < this.InputStream.Length; i++)
660                    input[i] = (byte)this.InputStream.ReadByte();
661                inputStream = new MemoryStream(input);
662            }
663            inputStream.Seek(0, 0);
664
665            CryptoStream crypto_stream = null;
666            byte[] output = new byte[blocksize];
667
668            //Decrypt Stream
669            try
670            {
671                if (!(des_algorithm is object))
672                {
673                    des_algorithm = new DESCryptoServiceProvider();
674                }
675
676                this.ConfigureAlg(des_algorithm, key);
677
678                ICryptoTransform p_decryptor;
679                try
680                {
681                    p_decryptor = des_algorithm.CreateDecryptor();
682                }
683                catch
684                {
685                    //dirty hack to allow weak keys:
686                    MethodInfo mi = des_algorithm.GetType().GetMethod("_NewEncryptor", BindingFlags.NonPublic | BindingFlags.Instance);
687                    object[] Par = { des_algorithm.Key, des_algorithm.Mode, des_algorithm.IV, des_algorithm.FeedbackSize, 0 };
688                    p_decryptor = mi.Invoke(des_algorithm, Par) as ICryptoTransform;
689                }
690
691                crypto_stream = new CryptoStream((Stream)inputStream, p_decryptor, CryptoStreamMode.Read);
692
693                byte[] buffer = new byte[des_algorithm.BlockSize / 8];
694                int bytesRead;
695                int position = 0;
696
697                while ((bytesRead = crypto_stream.Read(buffer, 0, buffer.Length)) > 0 && !plugin.isStopped())
698                {
699                    for (int i = 0; i < bytesRead; i++)
700                    {
701                        if (position + i < output.Length)
702                        {
703                            output[position + i] = buffer[i];
704                        }
705                        else
706                        {
707                            break;
708                        }
709                    }
710                    position += bytesRead;
711                }
712
713
714            }
715            catch (Exception exception)
716            {
717                des_algorithm = null;   // we got an exception so we do not use this object any more
718                throw exception;
719            }
720
721            return output;
722        }
723
724        [Obsolete("being used by obsolete Decrypt(byte[], int)")]
725        private void ConfigureAlg(SymmetricAlgorithm alg, byte[] key)
726        {
727            try
728            {
729                alg.Key = key;
730            }
731            catch
732            {
733                //dirty hack to allow weak keys:
734                FieldInfo field = des_algorithm.GetType().GetField("KeyValue", BindingFlags.NonPublic | BindingFlags.Instance);
735                field.SetValue(alg, key);
736            }
737
738            try
739            {
740                alg.IV = this.plugin.InputIV;
741            }
742            catch
743            {
744                //dirty hack to allow weak keys:
745                FieldInfo field = des_algorithm.GetType().GetField("IVValue", BindingFlags.NonPublic | BindingFlags.Instance);
746                field.SetValue(alg, this.plugin.InputIV);
747            }
748
749            switch (((DESSettings)plugin.Settings).Mode)
750            { //0="ECB"=default, 1="CBC", 2="CFB", 3="OFB"
751                case 1: alg.Mode = CipherMode.CBC; break;
752                case 2: alg.Mode = CipherMode.CFB; break;
753                case 3: alg.Mode = CipherMode.OFB; break;
754                default: alg.Mode = CipherMode.ECB; break;
755            }
756            switch (((DESSettings)plugin.Settings).Padding)
757            { //0="Zeros"=default, 1="None", 2="PKCS7"
758                case 1: alg.Padding = PaddingMode.None; break;
759                case 2: alg.Padding = PaddingMode.PKCS7; break;
760                case 3: alg.Padding = PaddingMode.ANSIX923; break;
761                case 4: alg.Padding = PaddingMode.ISO10126; break;
762                default: alg.Padding = PaddingMode.Zeros; break;
763            }
764
765        }
766
767        /// <summary>
768        /// Called by DES if its status changes
769        /// </summary>
770        public void onStatusChanged()
771        {
772            if (OnStatusChanged != null)
773                OnStatusChanged(this, true);
774        }
775
776        public string getKeyPattern()
777        {
778            return "[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]-"
779                +"[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]-[0-9A-F][0-9A-F]";
780        }
781
782        public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
783        {
784            byte[] bkey = new byte[8];
785            int counter = 0;
786            bool allocated = false;
787
788            for (int i = 0; i <= 7; i++)
789            {
790                string substr = key.Substring(i * 3, 2);
791
792                if (!allocated && (substr[0] == '*' || substr[1] == '*'))
793                {
794                    arrayPointers = new int[8];
795                    for (int j = 0; j < 8; j++)
796                        arrayPointers[j] = -1;
797                    arraySuccessors = new int[8];
798                    arrayUppers = new int[8];
799                    allocated = true;
800                }
801
802                if (substr[0] != '*' && substr[1] != '*')
803                    bkey[i] = Convert.ToByte(substr, 16);
804                else if (substr[0] == '*' && substr[1] == '*')
805                {
806                    bkey[i] = 0;
807                    arrayPointers[counter] = i;
808                    arraySuccessors[counter] = 1;
809                    arrayUppers[counter] = 255;
810                    counter++;
811                }
812                else if (substr[0] != '*' && substr[1] == '*')
813                {
814                    bkey[i] = Convert.ToByte(substr[0] + "0", 16);
815                    arrayPointers[counter] = i;
816                    arraySuccessors[counter] = 1;
817                    arrayUppers[counter] = Convert.ToByte(substr[0] + "F", 16);
818                    counter++;
819                }
820                else if (substr[0] == '*' && substr[1] != '*')
821                {
822                    bkey[i] = Convert.ToByte("0" + substr[1], 16);
823                    arrayPointers[counter] = i;
824                    arraySuccessors[counter] = 16;
825                    arrayUppers[counter] = Convert.ToByte("F" + substr[1], 16);
826                    counter++;
827                }
828            }
829            return bkey;
830        }
831
832        public IControlEncryption clone()
833        {
834            DESControl des = new DESControl(plugin);
835            CryptoolStream cs = new CryptoolStream();
836            cs.OpenRead(InputStream.FileName);
837            des.InputStream = cs;
838            des.reset();
839            return des;
840        }
841
842        public void Dispose()
843        {
844            closeStreams();
845        }
846
847        void IControlEncryption.changeSettings(string setting, object value)
848        {
849            throw new NotImplementedException();
850        }
851
852
853        #endregion
854    }
855}
Note: See TracBrowser for help on using the repository browser.