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

Last change on this file since 2061 was 2061, checked in by Sven Rech, 11 years ago

Added code to generate openCL bruteforce code in KeySearcher.
Not used yet, so don't try it

File size: 37.7 KB
Line 
1using System;
2using System.Collections.Generic;
3using System.Linq;
4using System.Text;
5using System.ComponentModel;
6using System.Threading;
7using System.Windows.Threading;
8using System.Runtime.InteropServices;
9
10using Cryptool;
11using Cryptool.PluginBase.IO;
12using Cryptool.PluginBase;
13using Cryptool.PluginBase.Cryptography;
14using Cryptool.PluginBase.Miscellaneous;
15using Cryptool.PluginBase.Control;
16
17namespace Transposition
18{
19    [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")]
20    [PluginInfo(false, "Transposition", "Transposition cipher", "Transposition/Description/TranspositionDescript.xaml", "Transposition/Images/icon.png", "Transposition/Images/encrypt.png", "Transposition/Images/decrypt.png")]
21    [EncryptionType(EncryptionType.Classic)]
22    public class Transposition : IEncryption
23    {
24        # region Private variables
25
26        private String keyword = "";
27        private byte[] input;
28        private byte[] output;
29        private TranspositionSettings settings;
30        private TranspositionPresentation myPresentation;
31        private byte[,] read_in_matrix;
32        private byte[,] permuted_matrix;
33        private int[] key;
34        private AutoResetEvent ars;
35        private Boolean b;
36
37        # endregion
38
39        /// <summary>
40        /// Constructor
41        /// </summary>
42        public Transposition()
43        {
44            this.settings = new TranspositionSettings();
45            myPresentation = new TranspositionPresentation();
46            Presentation = myPresentation;
47            ars =new AutoResetEvent(false);
48            myPresentation.feuerEnde += new EventHandler(presentation_finished);
49            myPresentation.updateProgress += new EventHandler(update_progress);
50            this.settings.PropertyChanged += settings_OnPropertyChange;
51            b = true;
52        }
53
54        private void update_progress(object sender, EventArgs e) 
55        {
56            TranspositionPresentation myhelp = new TranspositionPresentation();
57            myhelp = (TranspositionPresentation)sender;
58            ProgressChanged(myhelp.progress, 3000);
59        }
60
61        private void presentation_finished(object sender, EventArgs e)
62        {
63           
64            Output = output;
65            ProgressChanged(1, 1);
66            ars.Set(); 
67        }
68
69        private void settings_OnPropertyChange(object sender, PropertyChangedEventArgs e)
70        {
71            myPresentation.UpdateSpeed(this.settings.PresentationSpeed);
72        }
73        /// <summary>
74        /// Get or set all settings for this algorithm.
75        /// </summary>
76        public ISettings Settings
77        {
78            get { return this.settings; }
79            set { this.settings = (TranspositionSettings)value; }
80        }
81
82        # region getter methods
83
84        /// <summary>
85        /// Get read in matrix.
86        /// </summary>
87        public byte[,] Read_in_matrix
88        {
89            get
90            {
91                return read_in_matrix;
92            }
93        }
94
95        /// <summary>
96        /// Get permuted matrix.
97        /// </summary>
98        public byte[,] Permuted_matrix
99        {
100            get
101            {
102                return permuted_matrix;
103            }
104        }
105
106        /// <summary>
107        /// Get numerical key order.
108        /// </summary>
109        public int[] Key
110        {
111            get
112            {
113                return key;
114            }
115        }
116        # endregion
117
118        # region Properties
119
120        [PropertyInfo(Direction.InputData, "Input", "input", "Text to be encrypted.", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
121        public Byte[] Input
122        {
123            get
124            {
125                return this.input;
126            }
127
128            set
129            {
130                this.input = value;
131                OnPropertyChange("Input");
132            }
133        }
134
135        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "Keyword used for encryption", false, false, DisplayLevel.Beginner, QuickWatchFormat.Text, null)]
136        public string Keyword
137        {
138            get
139            {
140                return this.keyword;
141            }
142
143            set
144            {
145                this.keyword = value;
146                OnPropertyChange("Keyword");
147            }
148        }
149
150        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
151        public byte[] Output
152        {
153            get
154            {
155                return this.output;
156            }
157            set
158            {
159                this.output = value;
160                OnPropertyChange("Output");
161            }
162        }
163
164        private void OnPropertyChange(String propertyname)
165        {
166            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
167        }
168
169        private void ProgressChanged(double value, double max)
170        {
171            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
172        }
173
174        # endregion
175
176        #region IPlugin Member
177
178        public void Dispose()
179        {
180
181        }
182
183        public void Execute()
184        {
185           
186            Transposition_LogMessage("execute tr", NotificationLevel.Debug);
187            ProcessTransposition();
188            if (controlSlave is object && Input is object)
189            {
190                ((TranspositionControl)controlSlave).onStatusChanged();
191            }
192
193            if(b)
194            if (Presentation.IsVisible)
195            {
196                b = false;
197                    Presentation.Dispatcher.Invoke(DispatcherPriority.Normal, (SendOrPostCallback)delegate
198                   {
199                       myPresentation.main(Read_in_matrix, Permuted_matrix, key, Keyword, Input, output, this.settings.Permutation, this.settings.ReadIn, this.settings.ReadOut, this.settings.Action, this.settings.Number);
200                   }
201                   , null);
202
203                ars.WaitOne();
204                Thread.Sleep(1000);
205                b = true;
206            }
207            else
208            {
209                Output = output;
210                ProgressChanged(1, 1);
211            }
212           
213        }
214
215        public void Initialize()
216        {
217        }
218
219        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
220
221        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
222
223        public event StatusChangedEventHandler OnPluginStatusChanged;
224
225        public void Pause()
226        {
227
228        }
229
230        public void PostExecution()
231        {
232           
233        }
234
235        public void PreExecution()
236        {
237           
238        }
239
240        public System.Windows.Controls.UserControl Presentation
241        {
242            get;
243            private set;
244        }
245
246        public System.Windows.Controls.UserControl QuickWatchPresentation
247        {
248            get { return Presentation; }
249        }
250
251        public void Stop()
252        {
253            ars.Set();
254            myPresentation.my_Stop(this, EventArgs.Empty);
255        }
256
257        #endregion
258
259        #region INotifyPropertyChanged Member
260
261        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
262
263        #endregion
264
265        # region Private Methods
266
267        private void ProcessTransposition()
268        {
269            try
270            {
271                if (keyword.Contains(','))
272                {
273                    key = get_Keyword_Array(keyword);
274                }
275
276                else
277                {
278                    key = sortKey(keyword);
279                }
280               
281                switch (settings.Action)
282                {
283                    case 0:
284                        output = encrypt(input, key);
285                        break;
286                    case 1:
287                        output = decrypt(input, key);
288                        break;
289                    default:
290                        break;
291                }
292               
293            }
294
295            catch (Exception)
296            {
297                Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
298                Output = null;
299            }
300        }
301
302        private byte[] encrypt(byte[] input, int[] key)
303        {
304            if (key != null && input != null && key.Length > 0)
305            {
306                if (is_Valid_Keyword(key))
307                {
308                    byte[] encrypted = null;
309
310                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
311                    {
312                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
313                        {
314                            case TranspositionSettings.ReadInMode.byRow:
315                                read_in_matrix = enc_read_in_by_row_if_row_perm(input, key.Length); break;
316                            case TranspositionSettings.ReadInMode.byColumn:
317                                read_in_matrix = enc_read_in_by_column_if_row_perm(input, key.Length); break;
318                            default:
319                                break;
320                        }
321
322                        permuted_matrix = enc_permute_by_row(read_in_matrix, key);
323
324                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
325                        {
326                            case TranspositionSettings.ReadOutMode.byRow:
327                                encrypted = read_out_by_row_if_row_perm(permuted_matrix, key.Length); break;
328                            case TranspositionSettings.ReadOutMode.byColumn:
329                                encrypted = read_out_by_column_if_row_perm(permuted_matrix, key.Length); break;
330                            default:
331                                break;
332                        }
333                    }
334
335                    // permute by column:
336                    else
337                    {
338                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
339                        {
340                            case TranspositionSettings.ReadInMode.byRow:
341                                read_in_matrix = enc_read_in_by_row(input, key.Length); break;
342                            case TranspositionSettings.ReadInMode.byColumn:
343                                read_in_matrix = enc_read_in_by_column(input, key.Length); break;
344                            default:
345                                break;
346                        }
347
348                        permuted_matrix = enc_permut_by_column(read_in_matrix, key);
349
350                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
351                        {
352                            case TranspositionSettings.ReadOutMode.byRow:
353                                encrypted = read_out_by_row(permuted_matrix, key.Length); break;
354                            case TranspositionSettings.ReadOutMode.byColumn:
355                                encrypted = read_out_by_column(permuted_matrix, key.Length); break;
356                            default:
357                                break;
358                        }
359                    }
360                    return encrypted;
361                }
362                else
363                {
364                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
365                    return null;
366                }
367            }
368            else
369            {
370                // 2do: Anzeige "Kein gültiges Keyword
371                return null;
372            }
373        }
374
375        public byte[] decrypt(byte[] input, int[] new_key)
376        {
377            //Transposition_LogMessage("hier normales decrypt: " + new_key[0] + " / " +input[0], NotificationLevel.Debug);
378
379            if (new_key != null && input != null && new_key.Length > 0)
380            {
381                if (is_Valid_Keyword(new_key))
382                {
383                    byte[] decrypted = null;
384                    if (((TranspositionSettings.PermutationMode)settings.Permutation).Equals(TranspositionSettings.PermutationMode.byRow))
385                    {
386                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
387                        {
388                            case TranspositionSettings.ReadOutMode.byRow:
389                                read_in_matrix = dec_read_in_by_row_if_row_perm(input, new_key); break;
390                            case TranspositionSettings.ReadOutMode.byColumn:
391                                read_in_matrix = dec_read_in_by_column_if_row_perm(input, new_key); break;
392                            default:
393                                break;
394                        }
395
396                        permuted_matrix = dec_permut_by_row(read_in_matrix, new_key);
397
398                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
399                        {
400                            case TranspositionSettings.ReadInMode.byRow:
401                                decrypted = read_out_by_row_if_row_perm(permuted_matrix, new_key.Length); break;
402                            case TranspositionSettings.ReadInMode.byColumn:
403                                decrypted = read_out_by_column_if_row_perm(permuted_matrix, new_key.Length); break;
404                            default:
405                                break;
406                        }
407                    }
408
409                    // permute by column:
410                    else
411                    {
412                        switch ((TranspositionSettings.ReadOutMode)settings.ReadOut)
413                        {
414                            case TranspositionSettings.ReadOutMode.byRow:
415                                read_in_matrix = dec_read_in_by_row(input, new_key); break;
416                            case TranspositionSettings.ReadOutMode.byColumn:
417                                read_in_matrix = dec_read_in_by_column(input, new_key); break;
418                            default:
419                                break;
420                        }
421
422                        permuted_matrix = dec_permut_by_column(read_in_matrix, new_key);
423
424                        switch ((TranspositionSettings.ReadInMode)settings.ReadIn)
425                        {
426                            case TranspositionSettings.ReadInMode.byRow:
427                                decrypted = read_out_by_row(permuted_matrix, new_key.Length); break;
428                            case TranspositionSettings.ReadInMode.byColumn:
429                                decrypted = read_out_by_column(permuted_matrix, new_key.Length); break;
430                            default:
431                                break;
432                        }
433                    }
434                    return decrypted;
435                }
436                else
437                {
438                    Transposition_LogMessage("Keyword is not valid", NotificationLevel.Error);
439                    return null;
440                }
441            }
442            else
443            {
444                // 2do: Anzeige "Kein gültiges Keyword
445                return null;
446            }
447        }
448
449        private byte[,] enc_read_in_by_row(byte[] input, int keyword_length)
450        {
451            int size = input.Length / keyword_length;
452
453            if (input.Length % keyword_length != 0)
454            {
455                size++;
456            }
457
458            int pos = 0;
459            byte[,] matrix = new byte[keyword_length, size];
460
461            for (int i = 0; i < size; i++)
462            {
463                for (int j = 0; j < keyword_length; j++)
464                {
465                    if (pos < input.Length)
466                    {
467                        matrix[j, i] = input[pos];
468                        pos++;
469                    }
470                }
471            }
472            return matrix;
473        }
474
475        private byte[,] enc_read_in_by_column(byte[] input, int keyword_length)
476        {
477            int size = input.Length / keyword_length;
478            int offs = input.Length % keyword_length;
479            if (offs != 0)
480            {
481                size++;
482            }
483
484            int pos = 0;
485
486            byte[,] matrix = new byte[keyword_length, size];
487            for (int i = 0; i < keyword_length; i++)
488            {
489                for (int j = 0; j < size; j++)
490                {
491                    if (pos < input.Length)
492                    {
493                        if (offs > 0 && j == size - 1 && i >= offs) { }
494                        else
495                        {
496                            matrix[i, j] = input[pos];
497                            pos++;
498                        }
499                    }
500                }
501            }
502            return matrix;
503        }
504
505        private byte[,] enc_read_in_by_row_if_row_perm(byte[] input, int keyword_length)
506        {
507            int height = keyword_length;
508            int length = input.Length / keyword_length;
509            int offs = input.Length % keyword_length;
510            if (offs != 0)
511            {
512                length++;
513            }
514
515            byte[,] matrix = new byte[length, height];
516            int pos = 0;
517
518            for (int i = 0; i < height; i++)
519            {
520                for (int j = 0; j < length; j++)
521                {
522                    if (pos < input.Length)
523                    {
524                        if (j.Equals(length - 1) && offs != 0)
525                        {
526                            if (i < offs)
527                            {
528                                matrix[j, i] = input[pos];
529                                pos++;
530                            }
531                        }
532
533                        else
534                        {
535                            matrix[j, i] = input[pos];
536                            pos++;
537                        }
538                    }
539                }
540            }
541            return matrix;
542        }
543
544        private byte[,] enc_read_in_by_column_if_row_perm(byte[] input, int keyword_length)
545        {
546            int height = keyword_length;
547            int length = input.Length / keyword_length;
548            int offs = input.Length % keyword_length;
549            if (offs != 0)
550            {
551                length++;
552            }
553
554            byte[,] matrix = new byte[length, height];
555            int pos = 0;
556
557            for (int i = 0; i < length; i++)
558            {
559                for (int j = 0; j < height; j++)
560                {
561                    if (pos < input.Length)
562                    {
563                        matrix[i, j] = input[pos];
564                        pos++;
565                    }
566                }
567            }
568            return matrix;
569        }
570
571        private byte[,] dec_read_in_by_column(byte[] input, int[] keyword)
572        {
573            int size = input.Length / keyword.Length;
574            int offs = input.Length % keyword.Length;
575            if (offs != 0)
576            {
577                size++;
578            }
579
580            byte[,] matrix = new byte[keyword.Length, size];
581            int pos = 0;
582
583            for (int i = 0; i < keyword.Length; i++)
584            {
585                for (int j = 0; j < size; j++)
586                {
587                    if (pos < input.Length)
588                    {
589                        if ((!offs.Equals(0)) && j.Equals(size - 1))
590                        {
591                            bool ok = false;
592
593                            for (int k = 0; k < offs; k++)
594                            {
595                                if ((keyword[k] - 1).Equals(i))
596                                {
597                                    ok = true;
598                                }
599                            }
600
601                            if (ok)
602                            {
603                                matrix[i, j] = input[pos];
604                                pos++;
605                            }
606
607                        }
608                        else
609                        {
610                            matrix[i, j] = input[pos];
611                            pos++;
612                        }
613                    }
614                }
615            }
616            return matrix;
617        }
618
619        private byte[,] dec_read_in_by_column_if_row_perm(byte[] input, int[] keyword)
620        {
621            int size = input.Length / keyword.Length;
622            int offs = input.Length % keyword.Length;
623            if (offs != 0)
624            {
625                size++;
626            }
627
628            byte[,] matrix = new byte[size, keyword.Length];
629            int pos = 0;
630
631            for (int i = 0; i < size; i++)
632            {
633                for (int j = 0; j < keyword.Length; j++)
634                {
635                    if (pos < input.Length)
636                    {
637                        if ((!offs.Equals(0)) && i.Equals(size - 1))
638                        {
639                            bool ok = false;
640
641                            for (int k = 0; k < offs; k++)
642                            {
643                                if ((keyword[k] - 1).Equals(j))
644                                {
645                                    ok = true;
646                                }
647                            }
648
649                            if (ok)
650                            {
651                                matrix[i, j] = input[pos];
652                                pos++;
653                            }
654
655                        }
656                        else
657                        {
658                            matrix[i, j] = input[pos];
659                            pos++;
660                        }
661                    }
662                }
663            }
664            return matrix;
665        }
666
667        private byte[,] dec_read_in_by_row(byte[] input, int[] keyword)
668        {
669            int size = input.Length / keyword.Length;
670            int offs = input.Length % keyword.Length;
671            if (offs != 0)
672            {
673                size++;
674            }
675
676            byte[,] matrix = new byte[keyword.Length, size];
677            int pos = 0;
678
679            for (int i = 0; i < size; i++)
680            {
681                for (int j = 0; j < keyword.Length; j++)
682                {
683                    if (pos < input.Length)
684                    {
685                        if ((!offs.Equals(0)) && i.Equals(size - 1))
686                        {
687                            bool ok = false;
688
689                            for (int k = 0; k < offs; k++)
690                            {
691                                if ((keyword[k] - 1).Equals(j))
692                                {
693                                    ok = true;
694                                }
695                            }
696
697                            if (ok)
698                            {
699                                matrix[j, i] = input[pos];
700                                pos++;
701                            }
702
703                        }
704                        else
705                        {
706                            matrix[j, i] = input[pos];
707                            pos++;
708                        }
709                    }
710                }
711            }
712            return matrix;
713        }
714
715        private byte[,] dec_read_in_by_row_if_row_perm(byte[] input, int[] keyword)
716        {
717            int size = input.Length / keyword.Length;
718            int offs = input.Length % keyword.Length;
719            if (offs != 0)
720            {
721                size++;
722            }
723
724            byte[,] matrix = new byte[size, keyword.Length];
725            int pos = 0;
726
727            for (int i = 0; i < keyword.Length; i++)
728            {
729                for (int j = 0; j < size; j++)
730                {
731                    if (pos < input.Length)
732                    {
733                        if ((!offs.Equals(0)) && j.Equals(size - 1))
734                        {
735                            bool ok = false;
736
737                            for (int k = 0; k < offs; k++)
738                            {
739                                if ((keyword[k] - 1).Equals(i))
740                                {
741                                    ok = true;
742                                }
743                            }
744
745                            if (ok)
746                            {
747                                matrix[j, i] = input[pos];
748                                pos++;
749                            }
750
751                        }
752                        else
753                        {
754                            matrix[j, i] = input[pos];
755                            pos++;
756                        }
757                    }
758                }
759            }
760            return matrix;
761        }
762
763        private byte[,] enc_permut_by_column(byte[,] readin_matrix, int[] keyword)
764        {
765            int x = keyword.Length;
766            int y = readin_matrix.Length / keyword.Length;
767            byte[,] matrix = new byte[x, y];
768            int pos = 0;
769
770            for (int i = 1; i <= keyword.Length; i++)
771            {
772                for (int j = 0; j < keyword.Length; j++)
773                {
774                    if (i.Equals(keyword[j]))
775                    {
776                        pos = j;
777                    }
778                }
779
780                for (int j = 0; j < y; j++)
781                {
782                    matrix[i - 1, j] = readin_matrix[pos, j];
783                }
784            }
785            return matrix;
786        }
787
788        private byte[,] enc_permute_by_row(byte[,] readin_matrix, int[] keyword)
789        {
790            int y = keyword.Length;
791            int x = readin_matrix.Length / keyword.Length;
792            byte[,] matrix = new byte[x, y];
793            int pos = 0;
794
795            for (int i = 1; i <= y; i++)
796            {
797                for (int j = 0; j < keyword.Length; j++)
798                {
799                    if (keyword[j].Equals(i))
800                    {
801                        pos = j;
802                    }
803                }
804
805                for (int j = 0; j < x; j++)
806                {
807                    matrix[j, i - 1] = readin_matrix[j, pos];
808                }
809            }
810            return matrix;
811        }
812
813        private byte[,] dec_permut_by_column(byte[,] readin_matrix, int[] keyword)
814        {
815            int x = keyword.Length;
816            int y = readin_matrix.Length / keyword.Length;
817            byte[,] matrix = new byte[x, y];
818
819            for (int i = 0; i < x; i++)
820            {
821                for (int j = 0; j < y; j++)
822                {
823                    matrix[i, j] = readin_matrix[keyword[i] - 1, j];
824                }
825            }
826            return matrix;
827        }
828
829        private byte[,] dec_permut_by_row(byte[,] readin_matrix, int[] keyword)
830        {
831            int x = keyword.Length;
832            int y = readin_matrix.Length / keyword.Length;
833            byte[,] matrix = new byte[y, x];
834
835            for (int i = 0; i < x; i++)
836            {
837                for (int j = 0; j < y; j++)
838                {
839                    matrix[j, i] = readin_matrix[j, keyword[i] - 1];
840                }
841            }
842            return matrix;
843        }
844
845        private byte[] read_out_by_row(byte[,] matrix, int keyword_length)
846        {
847            int x = keyword_length;
848            int y = matrix.Length / keyword_length;
849            byte empty_byte = new byte();
850            int count_empty = 0;
851
852            for (int i = 0; i < y; i++)
853            {
854                for (int j = 0; j < x; j++)
855                {
856                    byte tmp = matrix[j, i];
857                    if (tmp.Equals(empty_byte))
858                    {
859                        count_empty++;
860                    }
861                }
862            }
863            byte[] enc = new byte[matrix.Length - count_empty];
864
865            int pos = 0;
866            for (int i = 0; i < y; i++)
867            {
868                for (int j = 0; j < x; j++)
869                {
870                    byte tmp = matrix[j, i];
871                    if (!tmp.Equals(empty_byte))
872                    {
873                        enc[pos] = tmp;
874                        pos++;
875                    }
876                }
877            }
878            return enc;
879        }
880
881        private byte[] read_out_by_row_if_row_perm(byte[,] matrix, int keyword_length)
882        {
883            int y = keyword_length;
884            int x = matrix.Length / keyword_length;
885
886            byte empty_byte = new byte();
887            int empty_count = 0;
888            for (int i = 0; i < y; i++)
889            {
890                for (int j = 0; j < x; j++)
891                {
892                    byte tmp = matrix[j, i];
893                    if (tmp.Equals(empty_byte))
894                    {
895                        empty_count++;
896                    }
897                }
898            }
899
900            byte[] enc = new byte[matrix.Length - empty_count];
901            int pos = 0;
902
903            for (int i = 0; i < y; i++)
904            {
905                for (int j = 0; j < x; j++)
906                {
907                    byte tmp = matrix[j, i];
908                    if (!tmp.Equals(empty_byte))
909                    {
910                        enc[pos] = tmp;
911                        pos++;
912                    }
913                }
914            }
915            return enc;
916        }
917
918        private byte[] read_out_by_column(byte[,] matrix, int keyword_length)
919        {
920            int x = keyword_length;
921            int y = matrix.Length / keyword_length;
922
923            byte empty_byte = new byte();
924            int empty_count = 0;
925
926            for (int i = 0; i < x; i++)
927            {
928                for (int j = 0; j < y; j++)
929                {
930                    byte tmp = matrix[i, j];
931                    if (tmp.Equals(empty_byte))
932                    {
933                        empty_count++;
934                    }
935                }
936            }
937
938            byte[] enc = new byte[matrix.Length - empty_count];
939            int pos = 0;
940            for (int i = 0; i < x; i++)
941            {
942                for (int j = 0; j < y; j++)
943                {
944                    byte tmp = matrix[i, j];
945                    if (!tmp.Equals(empty_byte) || tmp.Equals(null))
946                    {
947                        enc[pos] = tmp;
948                        pos++; 
949                    }
950                }
951            }
952            return enc;
953        }
954
955        private byte[] read_out_by_column_if_row_perm(byte[,] matrix, int keyword_length)
956        {
957            int y = keyword_length;
958            int x = matrix.Length / keyword_length;
959           
960            byte empty_byte = new byte();
961            int empty_count = 0;
962            for (int i = 0; i < x; i++)
963            {
964                for (int j = 0; j < y; j++)
965                {
966                    byte tmp = matrix[i, j];
967                    if (tmp.Equals(empty_byte))
968                    {
969                        empty_count++;
970                    }
971                }
972            }
973
974            byte[] enc = new byte[matrix.Length - empty_count];
975            int pos = 0;
976            for (int i = 0; i < x; i++)
977            {
978                for (int j = 0; j < y; j++)
979                {
980                    byte tmp = matrix[i, j];
981                    if (!tmp.Equals(empty_byte))
982                    {
983                        enc[pos] = tmp;
984                        pos++;
985                    }
986                }
987            }
988            return enc;
989        }
990
991        private int[] get_Keyword_Array(String keyword)
992        {
993            try
994            {
995                int length = 1;
996                char komma = ',';
997
998                for (int i = 0; i < keyword.Length; i++)
999                {
1000                    if (keyword[i].Equals(komma))
1001                    {
1002                        length++;
1003                    }
1004                }
1005
1006                int[] keys = new int[length];
1007                String tmp = "";
1008                int pos = 0;
1009                for (int i = 0; i < keyword.Length; i++)
1010                {
1011                    if (i.Equals(keyword.Length - 1))
1012                    {
1013                        tmp += keyword[i];
1014                        keys[pos] = Convert.ToInt32(tmp);
1015                    }
1016
1017                    else
1018                    {
1019                        if (keyword[i].Equals(komma))
1020                        {
1021                            keys[pos] = Convert.ToInt32(tmp);
1022                            tmp = "";
1023                            pos++;
1024                        }
1025                        else
1026                        {
1027                            tmp += keyword[i];
1028                        }
1029                    }
1030                }
1031                return keys;
1032            }
1033            catch (FormatException)
1034            {
1035                return null;
1036            }
1037        }
1038
1039        private bool is_Valid_Keyword(int[] keyword)
1040        {
1041            for (int i = 1; i <= keyword.Length; i++)
1042            {
1043                bool exists = false;
1044
1045                for (int j = 0; j < keyword.Length; j++)
1046                {
1047                    if (i.Equals(keyword[j]))
1048                    {
1049                        exists = true;
1050                    }
1051                }
1052
1053                if (!exists)
1054                {
1055                    return false;
1056                }
1057            }
1058            return true;
1059        }
1060
1061        public int[] sortKey(String input)
1062        {
1063            if (input != null && !input.Equals(""))
1064            {
1065                String key = input;
1066                Char[] keyChars = key.ToCharArray();
1067                Char[] orgChars = key.ToCharArray();
1068                int[] rank = new int[keyChars.Length];
1069                Array.Sort(keyChars);
1070
1071                for (int i = 0; i < orgChars.Length; i++)
1072                {
1073                    rank[i] = (Array.IndexOf(keyChars, orgChars[i])) + 1;
1074                    keyChars[Array.IndexOf(keyChars, orgChars[i])] = (char)0;
1075                }
1076                return rank;
1077            }
1078            return null;
1079        }
1080
1081        public void Transposition_LogMessage(string msg, NotificationLevel loglevel)
1082        {
1083            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(msg, this, loglevel));
1084        }
1085
1086        public void changeSettings(string setting, object value)
1087        {
1088            if (setting.Equals("ReadIn")) settings.ReadIn = (int)value;
1089            else if (setting.Equals("Permute")) settings.Permutation = (int)value;
1090            else if (setting.Equals("ReadOut")) settings.ReadOut = (int)value;
1091
1092        }
1093        # endregion
1094
1095        private IControlEncryption controlSlave;
1096        [PropertyInfo(Direction.ControlSlave, "Transposition Slave", "Transposition Slave", "", DisplayLevel.Experienced)]
1097        public IControlEncryption ControlSlave
1098        {
1099            get
1100            {
1101                if (controlSlave == null)
1102                    controlSlave = new TranspositionControl(this);
1103                return controlSlave;
1104            }
1105        }
1106    }
1107
1108    public class TranspositionControl : IControlEncryption
1109    {
1110        private Transposition plugin;
1111
1112
1113        public TranspositionControl(Transposition plugin)
1114        {
1115            this.plugin = plugin;
1116        }
1117
1118        #region IControlEncryption Member
1119
1120        public void setInput(Object input)
1121        {
1122            throw new NotImplementedException();
1123        }
1124       
1125        public byte[] Decrypt(byte[] key, int blocksize)
1126        {
1127            throw new NotImplementedException();
1128        }
1129
1130        public byte[] Decrypt(byte[] ciphertext, byte[] key, byte[] IV, int bytesToUse)
1131        {
1132            return Decrypt(ciphertext, key, IV);
1133        }
1134
1135        public byte[] Decrypt(byte[] ciphertext, byte[] key, byte[] IV)
1136        {
1137            if (plugin.Input != ciphertext)
1138            {
1139                plugin.Input = ciphertext;
1140            }
1141
1142            int[] k = new int[key.Length];
1143            for(int i=0; i<key.Length; i++)
1144            {
1145                k[i] = key[i];
1146            }
1147
1148            //plugin.Transposition_LogMessage("hier decrypt von control: " + k[0] + " / " +plugin.Input[0], NotificationLevel.Debug);
1149            return plugin.decrypt(plugin.Input, k);
1150        }
1151
1152        public byte[] Encrypt(byte[] key, int blocksize)
1153        {
1154            return null;
1155        }
1156
1157        public IControlEncryption clone()
1158        {
1159            return null;
1160        }
1161
1162        public string getKeyPattern()
1163        {
1164            return null;
1165        }
1166
1167        public void onStatusChanged()
1168        {
1169            if (OnStatusChanged != null)
1170                OnStatusChanged(this, true);
1171        }
1172
1173        public string GetOpenCLCode(int decryptionLength)
1174        {
1175            return null;
1176        }
1177
1178        public void changeSettings(string setting, object value)
1179        {
1180            plugin.changeSettings(setting, value);
1181        }
1182
1183        public IKeyTranslator getKeyTranslator()
1184        {
1185            throw new NotImplementedException();
1186        }
1187
1188        public event KeyPatternChanged keyPatternChanged;
1189
1190        #endregion
1191
1192        #region IControl Member
1193
1194        public event IControlStatusChangedEventHandler OnStatusChanged;
1195
1196        #endregion
1197
1198        #region IDisposable Member
1199
1200        public void Dispose()
1201        {
1202
1203        }
1204
1205        #endregion
1206    }
1207}
Note: See TracBrowser for help on using the repository browser.