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

Last change on this file since 781 was 781, checked in by malischewski, 12 years ago

Added sortKey method (returns a key as an array, e.g. "EZEBRA" -> [3,6,4,2,5,1])

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