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

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

some changes:
namespace, icon

added:

  • another function for transposition
  • regular expressions match sample
File size: 15.0 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
13
14namespace Transposition
15{
16
17    [Author("Daniel Kohnen", "kohnen@cryptool.org", "Uni Duisburg-Essen", "http://www.uni-due.de")]
18    [PluginInfo(false, "Transposition", "", "", "Transposition/icon.png")]
19    [EncryptionType(EncryptionType.Classic)]
20    public class Transposition : IEncryption
21    {
22        # region Private variables
23
24        private String keyword;
25        private String input;
26        private String output;
27        private TranspositionSettings settings;
28
29        # endregion
30
31        public Transposition()
32        {
33            this.settings = new TranspositionSettings();
34            keyword = "";
35            input = "";
36            output = "";
37        }
38
39        public ISettings Settings
40        {
41            get { return this.settings; }
42            set { this.settings = (TranspositionSettings)value; }
43        }
44
45        # region Properties
46
47        [PropertyInfo(Direction.InputData, "Input", "input", "", DisplayLevel.Beginner)]
48        public string Input
49        {
50            get
51            {
52                return this.input;
53            }
54
55            set
56            {
57                this.input = value;
58                OnPropertyChange("Input");
59            }
60        }
61
62        [PropertyInfo(Direction.InputData, "Keyword", "keyword", "", DisplayLevel.Beginner)]
63        public string Keyword
64        {
65            get
66            {
67                return this.keyword;
68            }
69
70            set
71            {
72                this.keyword = value;
73                OnPropertyChange("Keyword");
74            }
75        }
76
77        [PropertyInfo(Direction.OutputData, "Output", "output", "", DisplayLevel.Beginner)]
78        public string Output
79        {
80            get
81            {
82                return this.output;
83            }
84            set
85            {
86                this.output = value;
87                OnPropertyChange("Output");
88            }
89        }
90
91        private void OnPropertyChange(String propertyname)
92        {
93            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(propertyname));
94        }
95
96        private void ProgressChanged(double value, double max)
97        {
98            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
99        }
100
101        # endregion
102
103        #region IPlugin Member
104
105        public void Dispose()
106        {
107
108        }
109
110        public void Execute()
111        {
112            ProcessTransposition();
113        }
114
115        public void Initialize()
116        {
117
118        }
119
120        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
121
122        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
123
124        public event StatusChangedEventHandler OnPluginStatusChanged;
125
126        public void Pause()
127        {
128
129        }
130
131        public void PostExecution()
132        {
133
134        }
135
136        public void PreExecution()
137        {
138
139        }
140
141        public System.Windows.Controls.UserControl Presentation
142        {
143            get { return null; }
144        }
145
146        public System.Windows.Controls.UserControl QuickWatchPresentation
147        {
148            get { return null; }
149        }
150
151        public void Stop()
152        {
153
154        }
155
156        #endregion
157
158        #region INotifyPropertyChanged Member
159
160        public event System.ComponentModel.PropertyChangedEventHandler PropertyChanged;
161
162        #endregion
163
164        # region Private Methods
165
166        private void ProcessTransposition()
167        {
168
169            Output = encrypt_text(input, keyword);
170
171            ProgressChanged(1, 1);
172        }
173       
174        // old function
175        private String encrypt_text(String input, String keyword)
176        {
177            int[] keys = new int[keyword.Length];
178
179            for (int i = 1; i <= keyword.Length; i++)
180            {
181                for (int j = 0; j < keyword.Length; j++)
182                {
183                    if ((int)Char.GetNumericValue(keyword[j]) == i)
184                    {
185                        keys[i - 1] = j;
186                    }
187                }
188            }
189
190            String enc = "";
191
192            for (int j = 0; j < keyword.Length; j++)
193            {
194                for (int i = 0; i <= input.Length / keyword.Length; i++)
195                {
196                    int tmp = keys[j] + i * keyword.Length;
197
198                    if (tmp < input.Length)
199                    {
200                        enc += input[tmp];
201                    }
202                }
203            }
204
205            return enc;
206        }
207
208        // old function
209        private String decrypt_text(String input, String keyword)
210        {
211            int input_pos = 0;
212
213            int breite = keyword.Length;
214            int hoehe = input.Length / keyword.Length;
215            int offs = input.Length % keyword.Length;
216            if (offs != 0) { hoehe++; }
217
218            char[,] matrix = new char[breite, hoehe];
219
220            for (int i = 1; i <= keyword.Length; i++)
221            {
222                int pos = -1;
223
224                for (int j = 0; j < keyword.Length; j++)
225                {
226                    if (i == (int)Char.GetNumericValue(keyword[j]))
227                    {
228                        pos = j;
229                    }
230                }
231
232
233                if (offs != 0)
234                {
235                    if (pos < offs)
236                    {
237                        for (int j = 0; j < hoehe; j++)
238                        {
239                            matrix[pos, j] = input[input_pos];
240                            input_pos++;
241                        }
242                    }
243                    else
244                    {
245                        for (int j = 0; j < hoehe - 1; j++)
246                        {
247                            matrix[pos, j] = input[input_pos];
248                            input_pos++;
249                        }
250                    }
251                }
252
253                else
254                {
255                    for (int j = 0; j < hoehe; j++)
256                    {
257                        matrix[pos, j] = input[input_pos];
258                        input_pos++;
259                    }
260                }
261            }
262            String dec = "";
263
264            // Spaltenweise auslesen
265            // Read by line
266            for (int j = 0; j < hoehe; j++)
267            {
268                for (int i = 0; i < breite; i++)
269                {
270                    dec += matrix[i, j];
271                }
272            }
273            // Ende Spaltenweise auslesen
274            return dec;
275        }
276
277        private char[,] enc_read_in_by_row(String input, int keyword_length)
278        {
279            int size = input.Length / keyword_length;
280
281            if (input.Length % keyword_length != 0)
282            {
283                size++;
284            }
285
286            int pos = 0;
287
288            char[,] matrix = new char[keyword_length, size];
289            for (int i = 0; i < size; i++)
290            {
291                for (int j = 0; j < keyword_length; j++)
292                {
293                    if (pos < input.Length)
294                    {
295                        matrix[j, i] = input[pos];
296                        pos++;
297                    }                   
298                }
299            }
300
301            return matrix;
302        }
303
304        private char[,] enc_read_in_by_column(String input, int keyword_length)
305        {
306            int size = input.Length / keyword_length;
307            int offs = input.Length % keyword_length;
308            if (offs != 0)
309            {
310                size++;
311            }
312
313            int pos = 0;
314
315            char[,] matrix = new char[keyword_length, size];
316            for (int i = 0; i < keyword_length; i++)
317            {
318                for (int j = 0; j < size; j++)
319                {
320                    if (pos < input.Length)
321                    {
322                        if (offs > 0 && j == size - 1 && i >= offs) { }
323                        else
324                        {
325                            matrix[i, j] = input[pos];
326                            pos++;
327                        }
328                    }
329                }
330            }
331
332            return matrix;
333        }
334
335        private char[,] dec_read_in_by_row(String input, int[] keyword)
336        {
337            int size = input.Length / keyword.Length;
338
339            int offs = input.Length % keyword.Length;
340            if (offs != 0)
341            {
342                size++;
343            }
344
345            char[,] matrix = new char[keyword.Length, size];
346            int pos = 0;
347
348            for (int i = 0; i < keyword.Length; i++)
349            {
350                for (int j = 0; j < size; j++)
351                {
352                    if (pos < input.Length)
353                    {
354                        if ((!offs.Equals(0)) && j.Equals(size - 1))
355                        {
356                            bool ok = false;
357
358                            for (int k = 0; k < offs; k++)
359                            {                               
360                                if((keyword[k]-1).Equals(i))
361                                {
362                                    ok = true;
363                                }
364                            }
365
366                            if (ok)
367                            {
368                                matrix[i, j] = input[pos];
369                                pos++;
370                            }
371
372                        }
373                        else
374                        {
375                            matrix[i, j] = input[pos];
376                            pos++;
377                        }
378                    }
379                }
380            }
381
382
383            return matrix;
384        }
385
386        private char[,] dec_read_in_by_column(String input, int[] keyword)
387        {
388            int size = input.Length / keyword.Length;
389
390            int offs = input.Length % keyword.Length;
391            if (offs != 0)
392            {
393                size++;
394            }
395
396            char[,] matrix = new char[keyword.Length, size];
397            int pos = 0;
398
399            for (int i = 0; i < size; i++)
400            {
401                for (int j = 0; j < keyword.Length; j++)
402                {
403                    if (pos < input.Length)
404                    {
405                        if ((!offs.Equals(0)) && i.Equals(size - 1))
406                        {
407                            bool ok = false;
408
409                            for (int k = 0; k < offs; k++)
410                            {
411                                if ((keyword[k] - 1).Equals(j))
412                                {
413                                    ok = true;
414                                }
415                            }
416
417                            if (ok)
418                            {
419                                matrix[j, i] = input[pos];
420                                pos++;
421                            }
422
423                        }
424                        else
425                        {
426                            matrix[j, i] = input[pos];
427                            pos++;
428                        }
429                    }
430                }
431            }
432
433
434            return matrix;
435        }
436
437        private char[,] enc_permut_by_column(char[,] readin_matrix, int[] keyword)
438        {
439            int x = keyword.Length;
440            int y = readin_matrix.Length / keyword.Length;
441
442            char[,] matrix = new char[x,y];
443
444            int pos = 0;
445
446            for (int i = 1; i <= keyword.Length; i++)
447            {
448                for (int j = 0; j < keyword.Length; j++)
449                {
450                    if(i.Equals(keyword[j]))
451                    {
452                        pos = j;
453                    }
454                }
455
456                for (int j = 0; j < y; j++)
457                {
458                    matrix[i - 1, j] = readin_matrix[pos, j];
459                }
460            }
461
462            return matrix;
463        }
464
465        private char[,] dec_permut_by_column(char[,] readin_matrix, int[] keyword)
466        {
467            int x = keyword.Length;
468            int y = readin_matrix.Length / keyword.Length;
469
470            char[,] matrix = new char[x,y];
471
472            for (int i = 0; i < x; i++)
473            {
474                for (int j = 0; j < y; j++)
475                {
476                    matrix[i, j] = readin_matrix[keyword[i]-1, j];
477                }
478            }
479
480            return matrix;
481        }
482
483        private String read_out_by_row(char[,] matrix, int keyword_length)
484        {
485            int x = keyword_length;
486            int y = matrix.Length / keyword_length;
487
488            String enc = "";
489            char empty_char = new char();
490
491            for (int i = 0; i < y; i++)
492            {
493                for (int j = 0; j < x; j++)
494                {
495                    char tmp = matrix[j, i];
496                    if (! tmp.Equals(empty_char))
497                    {
498                        enc += tmp;
499                    }
500                }
501            }
502
503            return enc;
504        }
505
506        private String read_out_by_column(char[,] matrix, int keyword_length)
507        {
508            int x = keyword_length;
509            int y = matrix.Length / keyword_length;
510
511            String enc = "";
512            char empty_char = new char();
513
514            for (int i = 0; i < x; i++)
515            {
516                for (int j = 0; j < y; j++)
517                {
518                    char tmp = matrix[i, j];
519                    if (!tmp.Equals(empty_char))
520                    {
521                        enc += tmp;
522                    }
523                }
524            }
525
526            return enc;
527        }
528
529        private int[] get_Keyword_Array(String keyword)
530        {
531            int length = keyword.Length/2 + 1;
532            int[] keys = new int[length];
533
534            for (int i = 0; i < keyword.Length; i = i + 2)
535            {
536                keys[i / 2] = (int)Char.GetNumericValue(keyword[i]);
537            }
538
539            return keys;
540        }
541
542        private bool is_Valid_Keyword(int[] keyword)
543        {
544            for (int i = 1; i <= keyword.Length; i++)
545            {
546                bool exists = false;
547
548                for (int j = 0; j < keyword.Length; j++)
549                {
550                    if (i.Equals(keyword[j]))
551                    {
552                        exists = true;
553                    }
554                }
555
556                if (!exists)
557                {
558                    return false;
559                }
560            }
561
562            return true;
563        }
564   
565        # endregion
566    }
567}
Note: See TracBrowser for help on using the repository browser.