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

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

added some encryption/decryption functions

File size: 14.6 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 ClassLibrary1
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        private String encrypt_text(String input, String keyword)
175        {
176            int[] keys = new int[keyword.Length];
177
178            for (int i = 1; i <= keyword.Length; i++)
179            {
180                for (int j = 0; j < keyword.Length; j++)
181                {
182                    if ((int)Char.GetNumericValue(keyword[j]) == i)
183                    {
184                        keys[i - 1] = j;
185                    }
186                }
187            }
188
189            String enc = "";
190
191            for (int j = 0; j < keyword.Length; j++)
192            {
193                for (int i = 0; i <= input.Length / keyword.Length; i++)
194                {
195                    int tmp = keys[j] + i * keyword.Length;
196
197                    if (tmp < input.Length)
198                    {
199                        enc += input[tmp];
200                    }
201                }
202            }
203
204            return enc;
205        }
206
207        private String decrypt_text(String input, String keyword)
208        {
209            int input_pos = 0;
210
211            int breite = keyword.Length;
212            int hoehe = input.Length / keyword.Length;
213            int offs = input.Length % keyword.Length;
214            if (offs != 0) { hoehe++; }
215
216            char[,] matrix = new char[breite, hoehe];
217
218            for (int i = 1; i <= keyword.Length; i++)
219            {
220                int pos = -1;
221
222                for (int j = 0; j < keyword.Length; j++)
223                {
224                    if (i == (int)Char.GetNumericValue(keyword[j]))
225                    {
226                        pos = j;
227                    }
228                }
229
230
231                if (offs != 0)
232                {
233                    if (pos < offs)
234                    {
235                        for (int j = 0; j < hoehe; j++)
236                        {
237                            matrix[pos, j] = input[input_pos];
238                            input_pos++;
239                        }
240                    }
241                    else
242                    {
243                        for (int j = 0; j < hoehe - 1; j++)
244                        {
245                            matrix[pos, j] = input[input_pos];
246                            input_pos++;
247                        }
248                    }
249                }
250
251                else
252                {
253                    for (int j = 0; j < hoehe; j++)
254                    {
255                        matrix[pos, j] = input[input_pos];
256                        input_pos++;
257                    }
258                }
259            }
260            String dec = "";
261
262            // Spaltenweise auslesen
263            // Read by line
264            for (int j = 0; j < hoehe; j++)
265            {
266                for (int i = 0; i < breite; i++)
267                {
268                    dec += matrix[i, j];
269                }
270            }
271            // Ende Spaltenweise auslesen
272            return dec;
273        }
274
275        private char[,] enc_read_in_by_row(String input, int keyword_length)
276        {
277            int size = input.Length / keyword_length;
278
279            if (input.Length % keyword_length != 0)
280            {
281                size++;
282            }
283
284            int pos = 0;
285
286            char[,] matrix = new char[keyword_length, size];
287            for (int i = 0; i < size; i++)
288            {
289                for (int j = 0; j < keyword_length; j++)
290                {
291                    if (pos < input.Length)
292                    {
293                        matrix[j, i] = input[pos];
294                        pos++;
295                    }                   
296                }
297            }
298
299            return matrix;
300        }
301
302        private char[,] enc_read_in_by_column(String input, int keyword_length)
303        {
304            int size = input.Length / keyword_length;
305            int offs = input.Length % keyword_length;
306            if (offs != 0)
307            {
308                size++;
309            }
310
311            int pos = 0;
312
313            char[,] matrix = new char[keyword_length, size];
314            for (int i = 0; i < keyword_length; i++)
315            {
316                for (int j = 0; j < size; j++)
317                {
318                    if (pos < input.Length)
319                    {
320                        if (offs > 0 && j == size - 1 && i >= offs) { }
321                        else
322                        {
323                            matrix[i, j] = input[pos];
324                            pos++;
325                        }
326                    }
327                }
328            }
329
330            return matrix;
331        }
332
333        private char[,] dec_read_in_by_row(String input, int[] keyword)
334        {
335            int size = input.Length / keyword.Length;
336
337            int offs = input.Length % keyword.Length;
338            if (offs != 0)
339            {
340                size++;
341            }
342
343            char[,] matrix = new char[keyword.Length, size];
344            int pos = 0;
345
346            for (int i = 0; i < keyword.Length; i++)
347            {
348                for (int j = 0; j < size; j++)
349                {
350                    if (pos < input.Length)
351                    {
352                        if ((!offs.Equals(0)) && j.Equals(size - 1))
353                        {
354                            bool ok = false;
355
356                            for (int k = 0; k < offs; k++)
357                            {
358                                Console.WriteLine(k);
359                                if((keyword[k]-1).Equals(i))
360                                {
361                                    ok = true;
362                                }
363                            }
364
365                            if (ok)
366                            {
367                                matrix[i, j] = input[pos];
368                                pos++;
369                            }
370
371                        }
372                        else
373                        {
374                            matrix[i, j] = input[pos];
375                            pos++;
376                        }
377                    }
378                }
379            }
380
381
382            return matrix;
383        }
384
385        private char[,] dec_read_in_by_column(String input, int[] keyword)
386        {
387            int size = input.Length / keyword.Length;
388
389            int offs = input.Length % keyword.Length;
390            if (offs != 0)
391            {
392                size++;
393            }
394
395            char[,] matrix = new char[keyword.Length, size];
396            int pos = 0;
397
398            for (int i = 0; i < size; i++)
399            {
400                for (int j = 0; j < keyword.Length; j++)
401                {
402                    if (pos < input.Length)
403                    {
404                        if ((!offs.Equals(0)) && i.Equals(size - 1))
405                        {
406                            bool ok = false;
407
408                            for (int k = 0; k < offs; k++)
409                            {
410                                Console.WriteLine(k);
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                        Console.WriteLine("true");
453                        pos = j;
454                    }
455                }
456
457                for (int j = 0; j < y; j++)
458                {
459                    matrix[i - 1, j] = readin_matrix[pos, j];
460                }
461            }
462
463            return matrix;
464        }
465
466        private String enc_read_out_by_row(char[,] matrix, int keyword_length)
467        {
468            int x = keyword_length;
469            int y = matrix.Length / keyword_length;
470
471            String enc = "";
472            char empty_char = new char();
473
474            for (int i = 0; i < y; i++)
475            {
476                for (int j = 0; j < x; j++)
477                {
478                    char tmp = matrix[j, i];
479                    if (! tmp.Equals(empty_char))
480                    {
481                        enc += tmp;
482                    }
483                }
484            }
485
486            return enc;
487        }
488
489        private String enc_read_out_by_column(char[,] matrix, int keyword_length)
490        {
491            int x = keyword_length;
492            int y = matrix.Length / keyword_length;
493
494            String enc = "";
495            char empty_char = new char();
496
497            for (int i = 0; i < x; i++)
498            {
499                for (int j = 0; j < y; j++)
500                {
501                    char tmp = matrix[i, j];
502                    if (!tmp.Equals(empty_char))
503                    {
504                        enc += tmp;
505                    }
506                }
507            }
508
509            return enc;
510        }
511
512        private int[] get_Keyword_Array(String keyword)
513        {
514            int length = keyword.Length/2 + 1;
515            int[] keys = new int[length];
516
517            for (int i = 0; i < keyword.Length; i = i + 2)
518            {
519                keys[i / 2] = (int)Char.GetNumericValue(keyword[i]);
520            }
521
522            return keys;
523        }
524
525        private bool is_Valid_Keyword(int[] keyword)
526        {
527            for (int i = 1; i <= keyword.Length; i++)
528            {
529                bool exists = false;
530
531                for (int j = 0; j < keyword.Length; j++)
532                {
533                    if (i.Equals(keyword[j]))
534                    {
535                        exists = true;
536                    }
537                }
538
539                if (!exists)
540                {
541                    return false;
542                }
543            }
544
545            return true;
546        }
547    }
548        # endregion
549    }
550}
Note: See TracBrowser for help on using the repository browser.