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

Last change on this file since 801 was 801, checked in by kohnen, 12 years ago

getter methoden für presentation

File size: 29.7 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        private char[,] read_in_matrix;
28        private char[,] permuted_matrix;
29        # endregion
30
31        public Transposition()
32        {
33            this.settings = new TranspositionSettings();
34        }
35
36        public ISettings Settings
37        {
38            get { return this.settings; }
39            set { this.settings = (TranspositionSettings)value; }
40        }
41
42        # region getter methods
43
44        public char[,] Read_in_matrix
45        {
46            get
47            {
48                return read_in_matrix;
49            }
50        }
51
52        public char[,] Permuted_matrix
53        {
54            get
55            {
56                return permuted_matrix;
57            }
58        }
59        # endregion
60
61        # region Properties
62
63        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
64        public string Input
65        {
66            get
67            {
68                return this.input;
69            }
70
71            set
72            {
73                this.input = value;
74                OnPropertyChange("Input");
75            }
76        }
77
78        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", true, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
79        public string Keyword
80        {
81            get
82            {
83                return this.keyword;
84            }
85
86            set
87            {
88                this.keyword = value;
89                OnPropertyChange("Keyword");
90            }
91        }
92
93        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
94        public string Output
95        {
96            get
97            {
98                return this.output;
99            }
100            set
101            {
102                this.output = value;
103                OnPropertyChange("Output");
104            }
105        }
106
107        private void OnPropertyChange(String propertyname)
108        {
109            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
110        }
111
112        private void ProgressChanged(double value, double max)
113        {
114            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
115        }
116
117        # endregion
118
119        #region IPlugin Member
120
121        public void Dispose()
122        {
123
124        }
125
126        public void Execute()
127        {
128            ProcessTransposition();
129        }
130
131        public void Initialize()
132        {
133
134        }
135
136        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
137
138        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
139
140        public event StatusChangedEventHandler OnPluginStatusChanged;
141
142        public void Pause()
143        {
144
145        }
146
147        public void PostExecution()
148        {
149
150        }
151
152        public void PreExecution()
153        {
154
155        }
156
157        public System.Windows.Controls.UserControl Presentation
158        {
159            get { return null; }
160        }
161
162        public System.Windows.Controls.UserControl QuickWatchPresentation
163        {
164            get { return null; }
165        }
166
167        public void Stop()
168        {
169
170        }
171
172        #endregion
173
174        #region INotifyPropertyChanged Member
175
176        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
177
178        #endregion
179
180        # region Private Methods
181
182        private void ProcessTransposition()
183        {
184            try
185            {
186                int[] key = null;
187
188                if (keyword.Contains(','))
189                {
190                    key = get_Keyword_Array(keyword);
191                }
192
193                else
194                {
195                    key = sortKey(keyword);
196                }
197
198                switch (settings.Action)
199                {
200                    case 0:
201                        Output = encrypt(input, key);
202                        break;
203                    case 1:
204                        Output = decrypt(input, key);
205                        break;
206                    default:
207                        break;
208                }
209                ProgressChanged(1, 1);
210            }
211
212            catch (Exception)
213            {
214                Transposition_LogMessage("Keyword is not valid" , NotificationLevel.Error);
215                Output = "";
216            }
217        }
218
219        private String encrypt(String input, int[] key)
220        {
221            if (key != null && input != null && key.Length > 0)
222            {
223                if (is_Valid_Keyword(key))
224                {
225                    String encrypted = "";
226
227                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
228                    {
229                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
230                        {
231                            case TranspositionSettings.ReadInMode.byRow:
232                            read_in_matrix = enc_read_in_by_row_if_row_perm(input, key.Length); break;
233                            case TranspositionSettings.ReadInMode.byColumn:
234                                read_in_matrix = enc_read_in_by_column_if_row_perm(input, key.Length); break;
235                            default:
236                                break;
237                        }
238
239                        permuted_matrix = enc_permute_by_row(read_in_matrix, key);
240
241                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
242                        {
243                            case TranspositionSettings.ReadOutMode.byRow:
244                                encrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
245                            case TranspositionSettings.ReadOutMode.byColumn:
246                                encrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
247                            default:
248                                break;
249                        }
250                    }
251
252                    // permute by column:
253                    else
254                    {
255                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
256                        {
257                            case TranspositionSettings.ReadInMode.byRow:
258                                read_in_matrix = enc_read_in_by_row(input, key.Length); break;
259                            case TranspositionSettings.ReadInMode.byColumn:
260                                read_in_matrix = enc_read_in_by_column(input, key.Length); break;
261                            default:
262                                break;
263                        }
264
265                        permuted_matrix = enc_permut_by_column(read_in_matrix, key);
266
267                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
268                        {
269                            case TranspositionSettings.ReadOutMode.byRow:
270                                encrypted = read_out_by_row(permuted_matrix, key.Length); break;
271                            case TranspositionSettings.ReadOutMode.byColumn:
272                                encrypted = read_out_by_column(permuted_matrix, key.Length); break;
273                            default:
274                                break;
275                        }
276                    }
277
278                    return encrypted;
279                }
280                else
281                {
282                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
283                    return "";
284                }
285            }
286            else
287            {
288                // 2do: Anzeige "Kein gültiges Keyword
289                return "";
290            }
291        }
292
293        private String decrypt(String input, int[] key)
294        {
295            if (key != null && input != null && key.Length > 0)
296            {
297                if (is_Valid_Keyword(key))
298                {
299                    String decrypted = "";
300                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
301                    {
302                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
303                        {
304                            case TranspositionSettings.ReadOutMode.byRow:
305                                read_in_matrix = dec_read_in_by_row_if_row_perm(input, key); break;
306                            case TranspositionSettings.ReadOutMode.byColumn:
307                                read_in_matrix = dec_read_in_by_column_if_row_perm(input, key); break;
308                            default:
309                                break;
310                        }
311
312                        permuted_matrix = dec_permut_by_row(read_in_matrix, key);
313
314                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
315                        {
316                            case TranspositionSettings.ReadInMode.byRow:
317                                decrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
318                            case TranspositionSettings.ReadInMode.byColumn:
319                                decrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
320                            default:
321                                break;
322                        }
323                    }
324
325                    // permute by column:
326                    else
327                    {
328                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
329                        {
330                            case TranspositionSettings.ReadOutMode.byRow:
331                                read_in_matrix = dec_read_in_by_row(input, key); break;
332                            case TranspositionSettings.ReadOutMode.byColumn:
333                                read_in_matrix = dec_read_in_by_column(input, key); break;
334                            default:
335                                break;
336                        }
337
338                        permuted_matrix = dec_permut_by_column(read_in_matrix, key);
339
340                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
341                        {
342                            case TranspositionSettings.ReadInMode.byRow:
343                                decrypted = read_out_by_row(permuted_matrix, key.Length); break;
344                            case TranspositionSettings.ReadInMode.byColumn:
345                                decrypted = read_out_by_column(permuted_matrix, key.Length); break;
346                            default:
347                                break;
348                        }
349                    }
350
351                    return decrypted;
352                }
353                else
354                {
355                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
356                    return "";
357                }
358            }
359            else
360            {
361                // 2do: Anzeige "Kein gültiges Keyword
362                return "";
363            }
364        }
365
366        private char[,] enc_read_in_by_row(String input, int keyword_length)
367        {
368            int size = input.Length / keyword_length;
369
370            if (input.Length % keyword_length != 0)
371            {
372                size++;
373            }
374
375            int pos = 0;
376
377            char[,] matrix = new char[keyword_length, size];
378            for (int i = 0; i < size; i++)
379            {
380                for (int j = 0; j < keyword_length; j++)
381                {
382                    if (pos < input.Length)
383                    {
384                        matrix[j, i] = input[pos];
385                        pos++;
386                    }
387                }
388            }
389
390            return matrix;
391        }
392
393        private char[,] enc_read_in_by_column(String input, int keyword_length)
394        {
395            int size = input.Length / keyword_length;
396            int offs = input.Length % keyword_length;
397            if (offs != 0)
398            {
399                size++;
400            }
401
402            int pos = 0;
403
404            char[,] matrix = new char[keyword_length, size];
405            for (int i = 0; i < keyword_length; i++)
406            {
407                for (int j = 0; j < size; j++)
408                {
409                    if (pos < input.Length)
410                    {
411                        if (offs > 0 && j == size - 1 && i >= offs) { }
412                        else
413                        {
414                            matrix[i, j] = input[pos];
415                            pos++;
416                        }
417                    }
418                }
419            }
420
421            return matrix;
422        }
423
424        private char[,] enc_read_in_by_row_if_row_perm(String input, int keyword_length)
425        {
426            int height = keyword_length;
427            int length = input.Length / keyword_length;
428            int offs = input.Length % keyword_length;
429            if (offs != 0)
430            {
431                length++;
432            }
433
434            char[,] matrix = new char[length, height];
435            int pos = 0;
436
437            for (int i = 0; i < height; i++)
438            {
439                for (int j = 0; j < length; j++)
440                {
441                    if (pos < input.Length)
442                    {
443                        if (j.Equals(length - 1) && offs != 0)
444                        {
445                            if (i < offs)
446                            {
447                                matrix[j, i] = input[pos];
448                                pos++;
449                            }
450                        }
451
452                        else
453                        {
454                            matrix[j, i] = input[pos];
455                            pos++;
456                        }
457                    }
458                }
459            }
460
461            return matrix;
462        }
463
464        private char[,] enc_read_in_by_column_if_row_perm(String input, int keyword_length)
465        {
466            int height = keyword_length;
467            int length = input.Length / keyword_length;
468            int offs = input.Length % keyword_length;
469            if (offs != 0)
470            {
471                length++;
472            }
473
474            char[,] matrix = new char[length, height];
475            int pos = 0;
476
477            for (int i = 0; i < length; i++)
478            {
479                for (int j = 0; j < height; j++)
480                {
481                    if (pos < input.Length)
482                    {
483                        matrix[i, j] = input[pos];
484                        pos++;
485                    }
486                }
487            }
488
489            return matrix;
490        }
491
492        private char[,] dec_read_in_by_column(String input, int[] keyword)
493        {
494            int size = input.Length / keyword.Length;
495
496            int offs = input.Length % keyword.Length;
497            if (offs != 0)
498            {
499                size++;
500            }
501
502            char[,] matrix = new char[keyword.Length, size];
503            int pos = 0;
504
505            for (int i = 0; i < keyword.Length; i++)
506            {
507                for (int j = 0; j < size; j++)
508                {
509                    if (pos < input.Length)
510                    {
511                        if ((!offs.Equals(0)) && j.Equals(size - 1))
512                        {
513                            bool ok = false;
514
515                            for (int k = 0; k < offs; k++)
516                            {
517                                if ((keyword[k] - 1).Equals(i))
518                                {
519                                    ok = true;
520                                }
521                            }
522
523                            if (ok)
524                            {
525                                matrix[i, j] = input[pos];
526                                pos++;
527                            }
528
529                        }
530                        else
531                        {
532                            matrix[i, j] = input[pos];
533                            pos++;
534                        }
535                    }
536                }
537            }
538
539
540            return matrix;
541        }
542
543        private char[,] dec_read_in_by_column_if_row_perm(String input, int[] keyword)
544        {
545            int size = input.Length / keyword.Length;
546
547            int offs = input.Length % keyword.Length;
548            if (offs != 0)
549            {
550                size++;
551            }
552
553            char[,] matrix = new char[size, keyword.Length];
554            int pos = 0;
555
556            for (int i = 0; i < size; i++)
557            {
558                for (int j = 0; j < keyword.Length; j++)
559                {
560                    if (pos < input.Length)
561                    {
562                        if ((!offs.Equals(0)) && i.Equals(size - 1))
563                        {
564                            bool ok = false;
565
566                            for (int k = 0; k < offs; k++)
567                            {
568                                if ((keyword[k] - 1).Equals(j))
569                                {
570                                    ok = true;
571                                }
572                            }
573
574                            if (ok)
575                            {
576                                matrix[i, j] = input[pos];
577                                pos++;
578                            }
579
580                        }
581                        else
582                        {
583                            matrix[i, j] = input[pos];
584                            pos++;
585                        }
586                    }
587                }
588            }
589
590
591            return matrix;
592        }
593
594        private char[,] dec_read_in_by_row(String input, int[] keyword)
595        {
596            int size = input.Length / keyword.Length;
597
598            int offs = input.Length % keyword.Length;
599            if (offs != 0)
600            {
601                size++;
602            }
603
604            char[,] matrix = new char[keyword.Length, size];
605            int pos = 0;
606
607            for (int i = 0; i < size; i++)
608            {
609                for (int j = 0; j < keyword.Length; j++)
610                {
611                    if (pos < input.Length)
612                    {
613                        if ((!offs.Equals(0)) && i.Equals(size - 1))
614                        {
615                            bool ok = false;
616
617                            for (int k = 0; k < offs; k++)
618                            {
619                                if ((keyword[k] - 1).Equals(j))
620                                {
621                                    ok = true;
622                                }
623                            }
624
625                            if (ok)
626                            {
627                                matrix[j, i] = input[pos];
628                                pos++;
629                            }
630
631                        }
632                        else
633                        {
634                            matrix[j, i] = input[pos];
635                            pos++;
636                        }
637                    }
638                }
639            }
640
641
642            return matrix;
643        }
644
645        private char[,] dec_read_in_by_row_if_row_perm(String input, int[] keyword)
646        {
647            int size = input.Length / keyword.Length;
648
649            int offs = input.Length % keyword.Length;
650            if (offs != 0)
651            {
652                size++;
653            }
654
655            char[,] matrix = new char[size, keyword.Length];
656            int pos = 0;
657
658            for (int i = 0; i < keyword.Length; i++)
659            {
660                for (int j = 0; j < size; j++)
661                {
662                    if (pos < input.Length)
663                    {
664                        if ((!offs.Equals(0)) && j.Equals(size - 1))
665                        {
666                            bool ok = false;
667
668                            for (int k = 0; k < offs; k++)
669                            {
670                                if ((keyword[k] - 1).Equals(i))
671                                {
672                                    ok = true;
673                                }
674                            }
675
676                            if (ok)
677                            {
678                                matrix[j, i] = input[pos];
679                                pos++;
680                            }
681
682                        }
683                        else
684                        {
685                            matrix[j, i] = input[pos];
686                            pos++;
687                        }
688                    }
689                }
690            }
691
692
693            return matrix;
694        }
695
696        private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
697        {
698            int x = keyword.Length;
699            int y = readin_matrix.Length / keyword.Length;
700
701            char[,] matrix = new char[x, y];
702
703            int pos = 0;
704
705            for (int i = 1; i <= keyword.Length; i++)
706            {
707                for (int j = 0; j < keyword.Length; j++)
708                {
709                    if (i.Equals(keyword[j]))
710                    {
711                        pos = j;
712                    }
713                }
714
715                for (int j = 0; j < y; j++)
716                {
717                    matrix[i - 1, j] = readin_matrix[pos, j];
718                }
719            }
720
721            return matrix;
722        }
723
724        private char[,] enc_permute_by_row(char[,] readin_matrix, int[] keyword)
725        {
726            int y = keyword.Length;
727            int x = readin_matrix.Length / keyword.Length;
728
729            char[,] matrix = new char[x, y];
730
731            int pos = 0;
732
733            for (int i = 1; i <= y; i++)
734            {
735                for (int j = 0; j < keyword.Length; j++)
736                {
737                    if (keyword[j].Equals(i))
738                    {
739                        pos = j;
740                    }
741                }
742
743                for (int j = 0; j < x; j++)
744                {
745                    matrix[j, i - 1] = readin_matrix[j, pos];
746                }
747            }
748
749            return matrix;
750        }
751
752        private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
753        {
754            int x = keyword.Length;
755            int y = readin_matrix.Length / keyword.Length;
756
757            char[,] matrix = new char[x, y];
758
759            for (int i = 0; i < x; i++)
760            {
761                for (int j = 0; j < y; j++)
762                {
763                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
764                }
765            }
766
767            return matrix;
768        }
769
770        private static char[,] dec_permut_by_row(char[,] readin_matrix, int[] keyword)
771        {
772            int x = keyword.Length;
773            int y = readin_matrix.Length / keyword.Length;
774
775            char[,] matrix = new char[y, x];
776
777
778            for (int i = 0; i < x; i++)
779            {
780                for (int j = 0; j < y; j++)
781                {
782                    matrix[j, i] = readin_matrix[j, keyword[i] - 1];
783                }
784            }
785
786            return matrix;
787        }
788
789        private String read_out_by_row(char[,] matrix, int keyword_length)
790        {
791            int x = keyword_length;
792            int y = matrix.Length / keyword_length;
793
794            String enc = "";
795            char empty_char = new char();
796
797            for (int i = 0; i < y; i++)
798            {
799                for (int j = 0; j < x; j++)
800                {
801                    char tmp = matrix[j, i];
802                    if (!tmp.Equals(empty_char))
803                    {
804                        enc += tmp;
805                    }
806                }
807            }
808
809            return enc;
810        }
811
812        private String read_out_by_row_if_row_perm(char[,] matrix, int keyword_length)
813        {
814            int y = keyword_length;
815            int x = matrix.Length / keyword_length;
816
817            String enc = "";
818            char empty_char = new char();
819
820            for (int i = 0; i < y; i++)
821            {
822                for (int j = 0; j < x; j++)
823                {
824                    char tmp = matrix[j, i];
825                    if (!tmp.Equals(empty_char))
826                    {
827                        enc += tmp;
828                    }
829                }
830            }
831
832            return enc;
833        }
834
835        private String read_out_by_column(char[,] matrix, int keyword_length)
836        {
837            int x = keyword_length;
838            int y = matrix.Length / keyword_length;
839
840            String enc = "";
841            char empty_char = new char();
842
843            for (int i = 0; i < x; i++)
844            {
845                for (int j = 0; j < y; j++)
846                {
847                    char tmp = matrix[i, j];
848                    if (!tmp.Equals(empty_char))
849                    {
850                        enc += tmp;
851                    }
852                }
853            }
854
855            return enc;
856        }
857
858        private String read_out_by_column_if_row_perm(char[,] matrix, int keyword_length)
859        {
860            int y = keyword_length;
861            int x = matrix.Length / keyword_length;
862
863            String enc = "";
864            char empty_char = new char();
865
866            for (int i = 0; i < x; i++)
867            {
868                for (int j = 0; j < y; j++)
869                {
870                    char tmp = matrix[i, j];
871                    if (!tmp.Equals(empty_char))
872                    {
873                        enc += tmp;
874                    }
875                }
876            }
877
878            return enc;
879        }
880
881        private int[] get_Keyword_Array(String keyword)
882        {
883            try
884            {
885                int length = 1;
886                char komma = ',';
887
888                for (int i = 0; i < keyword.Length; i++)
889                {
890                    if (keyword[i].Equals(komma))
891                    {
892                        length++;
893                    }
894                }
895
896                int[] keys = new int[length];
897
898                String tmp = "";
899                int pos = 0;
900                for (int i = 0; i < keyword.Length; i++)
901                {
902                    if (i.Equals(keyword.Length - 1))
903                    {
904                        tmp += keyword[i];
905                        keys[pos] = Convert.ToInt32(tmp);
906                    }
907
908                    else
909                    {
910                        if (keyword[i].Equals(komma))
911                        {
912                            keys[pos] = Convert.ToInt32(tmp);
913                            tmp = "";
914                            pos++;
915                        }
916                        else
917                        {
918                            tmp += keyword[i];
919                        }
920                    }
921                }
922
923                return keys;
924            }
925            catch (FormatException)
926            {
927                return null;
928            }
929        }
930
931        private bool is_Valid_Keyword(int[] keyword)
932        {
933            for (int i = 1; i <= keyword.Length; i++)
934            {
935                bool exists = false;
936
937                for (int j = 0; j < keyword.Length; j++)
938                {
939                    if (i.Equals(keyword[j]))
940                    {
941                        exists = true;
942                    }
943                }
944
945                if (!exists)
946                {
947                    return false;
948                }
949            }
950
951            return true;
952        }
953
954        public int[] sortKey(String input)
955        {
956            if (input != null && !input.Equals(""))
957            {
958                String key = input;
959                Char[] keyChars = key.ToCharArray();
960                Char[] orgChars = key.ToCharArray();
961                int[] rank = new int[keyChars.Length];
962                Array.Sort(keyChars);
963
964                for (int i = 0; i < orgChars.Length; i++)
965                {
966                    rank[i] = (Array.IndexOf(keyChars, orgChars[i])) + 1;
967                    keyChars[Array.IndexOf(keyChars, orgChars[i])] = (char)0;
968                }
969
970                return rank;
971            }
972            return null;
973        }
974
975        private void Transposition_LogMessage(string msg, NotificationLevel loglevel)
976        {
977            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
978
979        }
980
981        # endregion
982    }
983}
Note: See TracBrowser for help on using the repository browser.