source: trunk/CrypPlugins/Transposition/Transposition.cs @ 782

Last change on this file since 782 was 782, checked in by kohnen, 12 years ago
  • text-keywords may be used
  • double transposition added
File size: 21.4 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.ComponentModel;
6
7using Cryptool;
8using Cryptool.PluginBase.IO;
9using Cryptool.PluginBase;
10using Cryptool.PluginBase.Cryptography;
11using Cryptool.PluginBase.Miscellaneous;
12
13namespace Transposition
14{
15    [Author("Daniel Kohnen, Julian Weyers, Simon Malischewski, Armin Wiefels", "kohnen@cryptool.org, weyers@cryptool.org, malischewski@cryptool.org, wiefels@cryptool.org", "Universität Duisburg-Essen", "http://www.uni-due.de")]
16    [PluginInfo(false, "Transposition", "", "", "Transposition/Images/icon.png", "Transposition/Images/encrypt.png", "Transposition/Images/decrypt.png")]
17    [EncryptionType(EncryptionType.Classic)]
18    public class Transposition : IEncryption
19    {
20        # region Private variables
21
22        private String keyword = "";
23        private String dpkeyword = "";
24        private String input = "";
25        private String output = "";
26        private TranspositionSettings settings;
27
28        # endregion
29
30        public Transposition()
31        {
32            this.settings = new TranspositionSettings();
33        }
34
35        public ISettings Settings
36        {
37            get { return this.settings; }
38            set { this.settings = (TranspositionSettings)value; }
39        }
40
41        # region Properties
42
43        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
44        public string Input
45        {
46            get
47            {
48                return this.input;
49            }
50
51            set
52            {
53                this.input = value;
54                OnPropertyChange("Input");
55            }
56        }
57
58        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
59        public string Keyword
60        {
61            get
62            {
63                return this.keyword;
64            }
65
66            set
67            {
68                this.keyword = value;
69                OnPropertyChange("Keyword");
70            }
71        }
72
73        [PropertyInfo(Direction.InputData, "Double transposition keyword", "double transposition keyword", "Keyword ued for double transposition. If empty, the first keyword is used for the second transposition, too.", DisplayLevel.Beginner)]
74        public string DoubleTransposition
75        {
76            get
77            {
78                return this.dpkeyword;
79            }
80            set
81            {
82                this.dpkeyword = value;
83                OnPropertyChange("DoubleTransposition");
84            }
85        }
86
87
88        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
89        public string Output
90        {
91            get
92            {
93                return this.output;
94            }
95            set
96            {
97                this.output = value;
98                OnPropertyChange("Output");
99            }
100        }
101
102        private void OnPropertyChange(String propertyname)
103        {
104            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
105        }
106
107        private void ProgressChanged(double value, double max)
108        {
109            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
110        }
111
112        # endregion
113
114        #region IPlugin Member
115
116        public void Dispose()
117        {
118
119        }
120
121        public void Execute()
122        {
123            ProcessTransposition();
124        }
125
126        public void Initialize()
127        {
128
129        }
130
131        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
132
133        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
134
135        public event StatusChangedEventHandler OnPluginStatusChanged;
136
137        public void Pause()
138        {
139
140        }
141
142        public void PostExecution()
143        {
144
145        }
146
147        public void PreExecution()
148        {
149
150        }
151
152        public System.Windows.Controls.UserControl Presentation
153        {
154            get { return null; }
155        }
156
157        public System.Windows.Controls.UserControl QuickWatchPresentation
158        {
159            get { return null; }
160        }
161
162        public void Stop()
163        {
164
165        }
166
167        #endregion
168
169        #region INotifyPropertyChanged Member
170
171        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
172
173        #endregion
174
175        # region Private Methods
176
177        private void ProcessTransposition()
178        {
179            try
180            {
181                int[] key = null;
182                int[] dpkey = null;
183
184                if (keyword.Contains('1'))
185                {
186                    key = get_Keyword_Array(keyword);
187                }
188
189                else
190                {
191                    key = sortKey(keyword);
192                }
193
194
195                if (DoubleTransposition == null || DoubleTransposition.Equals(""))
196                {
197                    dpkey = key;
198                }
199
200                else
201                {
202                    if (dpkeyword.Contains('1'))
203                    {
204                        dpkey = get_Keyword_Array(dpkeyword);
205                    }
206
207                    else
208                    {
209                        dpkey = sortKey(dpkeyword);
210                    }
211                }
212
213                if (settings.DoubleTransposition)
214                {
215                    switch (settings.Action)
216                    {
217                        case 0:
218                            String enc_tmp = encrypt(input, key);
219                            Output = encrypt(enc_tmp, dpkey);
220                            break;
221
222                        case 1:
223                            String dec_tmp = decrypt(input, dpkey);
224                            Output = decrypt(dec_tmp, key);
225                            break;
226
227                        default:
228                            break;
229                    }
230                }
231
232                else
233                {
234                    switch (settings.Action)
235                    {
236
237                        case 0:
238                            Output = encrypt(input, key);
239                            break;
240                        case 1:
241                            Output = decrypt(input, key);
242                            break;
243                        default:
244                            break;
245                    }
246                }
247
248                ProgressChanged(1, 1);
249            }
250
251            catch (Exception)
252            {
253                Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
254                Output = "";
255            }
256        }
257
258        private String encrypt(String input, int[] key)
259        {
260            if (key != null && input != null && key.Length>0)
261            {
262                if (is_Valid_Keyword(key))
263                {
264                    char[,] matrix = null;
265
266                    switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
267                    {
268                        case TranspositionSettings.ReadInMode.byRow:
269                            matrix = enc_read_in_by_row(input, key.Length); break;
270                        case TranspositionSettings.ReadInMode.byColumn:
271                            matrix = enc_read_in_by_column(input, key.Length); break;
272                        default:
273                            break;
274                    }
275
276                    switch ((TranspositionSettings.PermutationMode)settings.Permutation)
277                    {
278                        case TranspositionSettings.PermutationMode.byColumn:
279                            matrix = enc_permut_by_column(matrix, key); break;
280
281                        // Permute by row still to do
282                        case TranspositionSettings.PermutationMode.byRow:
283                            matrix = enc_permut_by_column(matrix, key); break;
284                        default:
285                            break;
286                    }
287
288                    String encrypted = "";
289
290                    switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
291                    {
292                        case TranspositionSettings.ReadOutMode.byRow:
293                            encrypted = read_out_by_row(matrix, key.Length); break;
294                        case TranspositionSettings.ReadOutMode.byColumn:
295                            encrypted = read_out_by_column(matrix, key.Length); break;
296                        default:
297                            break;
298                    }
299
300                    return encrypted;
301                }
302                else
303                {
304                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
305                    return "";
306                }
307            }
308            else
309            {
310                // 2do: Anzeige "Kein gültiges Keyword
311                return "";
312            }
313        }
314
315        private String decrypt(String input, int[] key)
316        {
317            if (key != null && input != null && key.Length>0)
318            {
319                if (is_Valid_Keyword(key))
320                {
321                    char[,] matrix = null;
322
323                    switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
324                    {
325                        case TranspositionSettings.ReadOutMode.byRow:
326                            matrix = dec_read_in_by_column(input, key); break;
327                        case TranspositionSettings.ReadOutMode.byColumn:
328                            matrix = dec_read_in_by_row(input, key); break;
329                        default:
330                            break;
331                    }
332
333                    switch ((TranspositionSettings.PermutationMode)settings.Permutation)
334                    {
335                        case TranspositionSettings.PermutationMode.byRow:
336                            matrix = dec_permut_by_column(matrix, key); break;
337
338                        // Permute by row still to do
339                        case TranspositionSettings.PermutationMode.byColumn:
340                            matrix = dec_permut_by_column(matrix, key); break;
341                        default:
342                            break;
343                    }
344
345                    String decrypted = "";
346
347                    switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
348                    {
349                        case TranspositionSettings.ReadInMode.byRow:
350                            decrypted = read_out_by_row(matrix, key.Length); break;
351                        case TranspositionSettings.ReadInMode.byColumn:
352                            decrypted = read_out_by_column(matrix, key.Length); break;
353                        default:
354                            break;
355                    }
356
357                    return decrypted;
358                }
359                else
360                {
361                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
362                    return "";
363                }
364            }
365            else
366            {
367                // 2do: Anzeige "Kein gültiges Keyword
368                return "";
369            }
370        }
371
372        private char[,] enc_read_in_by_row(String input, int keyword_length)
373        {
374            int size = input.Length / keyword_length;
375
376            if (input.Length % keyword_length != 0)
377            {
378                size++;
379            }
380
381            int pos = 0;
382
383            char[,] matrix = new char[keyword_length, size];
384            for (int i = 0; i < size; i++)
385            {
386                for (int j = 0; j < keyword_length; j++)
387                {
388                    if (pos < input.Length)
389                    {
390                        matrix[j, i] = input[pos];
391                        pos++;
392                    }
393                }
394            }
395
396            return matrix;
397        }
398
399        private char[,] enc_read_in_by_column(String input, int keyword_length)
400        {
401            int size = input.Length / keyword_length;
402            int offs = input.Length % keyword_length;
403            if (offs != 0)
404            {
405                size++;
406            }
407
408            int pos = 0;
409
410            char[,] matrix = new char[keyword_length, size];
411            for (int i = 0; i < keyword_length; i++)
412            {
413                for (int j = 0; j < size; j++)
414                {
415                    if (pos < input.Length)
416                    {
417                        if (offs > 0 && j == size - 1 && i >= offs) { }
418                        else
419                        {
420                            matrix[i, j] = input[pos];
421                            pos++;
422                        }
423                    }
424                }
425            }
426
427            return matrix;
428        }
429
430        private char[,] dec_read_in_by_row(String input, int[] keyword)
431        {
432            int size = input.Length / keyword.Length;
433
434            int offs = input.Length % keyword.Length;
435            if (offs != 0)
436            {
437                size++;
438            }
439
440            char[,] matrix = new char[keyword.Length, size];
441            int pos = 0;
442
443            for (int i = 0; i < keyword.Length; i++)
444            {
445                for (int j = 0; j < size; j++)
446                {
447                    if (pos < input.Length)
448                    {
449                        if ((!offs.Equals(0)) && j.Equals(size - 1))
450                        {
451                            bool ok = false;
452
453                            for (int k = 0; k < offs; k++)
454                            {
455                                if ((keyword[k] - 1).Equals(i))
456                                {
457                                    ok = true;
458                                }
459                            }
460
461                            if (ok)
462                            {
463                                matrix[i, j] = input[pos];
464                                pos++;
465                            }
466
467                        }
468                        else
469                        {
470                            matrix[i, j] = input[pos];
471                            pos++;
472                        }
473                    }
474                }
475            }
476
477
478            return matrix;
479        }
480
481        private char[,] dec_read_in_by_column(String input, int[] keyword)
482        {
483            int size = input.Length / keyword.Length;
484
485            int offs = input.Length % keyword.Length;
486            if (offs != 0)
487            {
488                size++;
489            }
490
491            char[,] matrix = new char[keyword.Length, size];
492            int pos = 0;
493
494            for (int i = 0; i < size; i++)
495            {
496                for (int j = 0; j < keyword.Length; j++)
497                {
498                    if (pos < input.Length)
499                    {
500                        if ((!offs.Equals(0)) && i.Equals(size - 1))
501                        {
502                            bool ok = false;
503
504                            for (int k = 0; k < offs; k++)
505                            {
506                                if ((keyword[k] - 1).Equals(j))
507                                {
508                                    ok = true;
509                                }
510                            }
511
512                            if (ok)
513                            {
514                                matrix[j, i] = input[pos];
515                                pos++;
516                            }
517
518                        }
519                        else
520                        {
521                            matrix[j, i] = input[pos];
522                            pos++;
523                        }
524                    }
525                }
526            }
527
528
529            return matrix;
530        }
531
532        private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
533        {
534            int x = keyword.Length;
535            int y = readin_matrix.Length / keyword.Length;
536
537            char[,] matrix = new char[x, y];
538
539            int pos = 0;
540
541            for (int i = 1; i <= keyword.Length; i++)
542            {
543                for (int j = 0; j < keyword.Length; j++)
544                {
545                    if (i.Equals(keyword[j]))
546                    {
547                        pos = j;
548                    }
549                }
550
551                for (int j = 0; j < y; j++)
552                {
553                    matrix[i - 1, j] = readin_matrix[pos, j];
554                }
555            }
556
557            return matrix;
558        }
559
560        private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
561        {
562            int x = keyword.Length;
563            int y = readin_matrix.Length / keyword.Length;
564
565            char[,] matrix = new char[x, y];
566
567            for (int i = 0; i < x; i++)
568            {
569                for (int j = 0; j < y; j++)
570                {
571                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
572                }
573            }
574
575            return matrix;
576        }
577
578        private String read_out_by_row(char[,] matrix, int keyword_length)
579        {
580            int x = keyword_length;
581            int y = matrix.Length / keyword_length;
582
583            String enc = "";
584            char empty_char = new char();
585
586            for (int i = 0; i < y; i++)
587            {
588                for (int j = 0; j < x; j++)
589                {
590                    char tmp = matrix[j, i];
591                    if (!tmp.Equals(empty_char))
592                    {
593                        enc += tmp;
594                    }
595                }
596            }
597
598            return enc;
599        }
600
601        private String read_out_by_column(char[,] matrix, int keyword_length)
602        {
603            int x = keyword_length;
604            int y = matrix.Length / keyword_length;
605
606            String enc = "";
607            char empty_char = new char();
608
609            for (int i = 0; i < x; i++)
610            {
611                for (int j = 0; j < y; j++)
612                {
613                    char tmp = matrix[i, j];
614                    if (!tmp.Equals(empty_char))
615                    {
616                        enc += tmp;
617                    }
618                }
619            }
620
621            return enc;
622        }
623
624        private int[] get_Keyword_Array(String keyword)
625        {
626            try
627            {
628                int length = 1;
629                char komma = ',';
630
631                for (int i = 0; i < keyword.Length; i++)
632                {
633                    if (keyword[i].Equals(komma))
634                    {
635                        length++;
636                    }
637                }
638
639                int[] keys = new int[length];
640
641                String tmp = "";
642                int pos = 0;
643                for (int i = 0; i < keyword.Length; i++)
644                {
645                    if (i.Equals(keyword.Length - 1))
646                    {
647                        tmp += keyword[i];
648                        keys[pos] = Convert.ToInt32(tmp);
649                    }
650
651                    else
652                    {
653                        if (keyword[i].Equals(komma))
654                        {
655                            keys[pos] = Convert.ToInt32(tmp);
656                            tmp = "";
657                            pos++;
658                        }
659                        else
660                        {
661                            tmp += keyword[i];
662                        }
663                    }
664                }
665
666                return keys;
667            }
668            catch (FormatException)
669            {
670                return null;
671            }
672        }
673
674        private bool is_Valid_Keyword(int[] keyword)
675        {
676            for (int i = 1; i <= keyword.Length; i++)
677            {
678                bool exists = false;
679
680                for (int j = 0; j < keyword.Length; j++)
681                {
682                    if (i.Equals(keyword[j]))
683                    {
684                        exists = true;
685                    }
686                }
687
688                if (!exists)
689                {
690                    return false;
691                }
692            }
693
694            return true;
695        }
696               
697                 public int[] sortKey(String input)
698        {
699            if (input != null && !input.Equals(""))
700            {
701                String key = input;
702                Char[] keyChars = key.ToCharArray();
703                Char[] orgChars = key.ToCharArray();
704                int[] rank = new int[keyChars.Length];
705                Array.Sort(keyChars);
706
707                for (int i = 0; i < orgChars.Length; i++)
708                {
709                    rank[i] = (Array.IndexOf(keyChars, orgChars[i])) + 1;
710                    keyChars[Array.IndexOf(keyChars, orgChars[i])] = (char)0;
711                }
712
713                return rank;
714            }
715            return null;
716        }
717
718        private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
719        {
720            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
721
722        }
723     
724        # endregion
725    }
726}
Note: See TracBrowser for help on using the repository browser.