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

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

Fixed IControl issues with Transposition Slave / TranspositionAnalyzer, Plugin working again.

File size: 37.4 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 byte[] Decrypt(byte[] ciphertext, byte[] key)
1121        {
1122            throw new NotImplementedException();
1123        }
1124
1125        public byte[] Decrypt(byte[] key, int blocksize)
1126        {
1127            int[] k = new int[key.Length];
1128            for(int i=0; i<key.Length; i++)
1129            {
1130                k[i] = key[i];
1131            }
1132
1133            //plugin.Transposition_LogMessage("hier decrypt von control: " + k[0] + " / " +plugin.Input[0], NotificationLevel.Debug);
1134            return plugin.decrypt(plugin.Input, k);
1135        }
1136
1137        public byte[] Encrypt(byte[] key, int blocksize)
1138        {
1139            return null;
1140        }
1141
1142        public IControlEncryption clone()
1143        {
1144            return null;
1145        }
1146
1147        public byte[] getKeyFromString(string key, ref int[] arrayPointers, ref int[] arraySuccessors, ref int[] arrayUppers)
1148        {
1149            return null;
1150        }
1151
1152        public string getKeyPattern()
1153        {
1154            return null;
1155        }
1156
1157        public void setInput(Object input)
1158        {
1159            plugin.Input = (byte[])input;
1160        }
1161
1162        public void onStatusChanged()
1163        {
1164            if (OnStatusChanged != null)
1165                OnStatusChanged(this, true);
1166        }
1167
1168        public void changeSettings(string setting, object value)
1169        {
1170            plugin.changeSettings(setting, value);
1171        }
1172
1173        public event KeyPatternChanged keyPatternChanged;
1174
1175        #endregion
1176
1177        #region IControl Member
1178
1179        public event IControlStatusChangedEventHandler OnStatusChanged;
1180
1181        #endregion
1182
1183        #region IDisposable Member
1184
1185        public void Dispose()
1186        {
1187
1188        }
1189
1190        #endregion
1191    }
1192}
Note: See TracBrowser for help on using the repository browser.