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

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

permutation "by row" added

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