source: trunk/CrypPlugins/SZ42/SZ42.cs @ 1941

Last change on this file since 1941 was 1941, checked in by Wilmer Andres Daza Gomez, 11 years ago

Begin of the plugin SZ42 German Lorenz Machine
until now the plugin works fine but need to be test it

File size: 15.2 KB
Line 
1using System;
2using System.Collections.Generic;
3
4namespace Cryptool.Plugins.SZ42
5{
6    /// <summary>
7    /// Class that represents a SZ42 machine cipher
8    /// </summary>
9    [Serializable]
10    public class SZ42
11    {
12        #region Private Variables
13
14        char basicMotor, totalMotor, limitation;
15
16        bool theresLimitation;
17
18        //Chi wheels of the SZ42
19        Wheel[] chiWheels;
20
21        //Psi wheels of the SZ42
22        Wheel[] psiWheels;
23
24        //Mu wheels of the SZ42
25        Wheel[] muWheels;
26
27        //This dictionary contains the badout code with
28        //the corresponding character e.g. T -> ...x
29        Dictionary<char, string> baudotCode = new Dictionary<char, string>();
30
31        //This dictionary contains character with
32        //the corresponding badout code e.g. ...x -> T
33        Dictionary<string, char> charCode = new Dictionary<string, char>();
34
35        //This dictionary contains figures with
36        //the corresponding letters e.g.  + -> Z
37        Dictionary<char, char> charToFigures = new Dictionary<char, char>();
38
39        //This dictionary contains figures with
40        //the corresponding letters e.g.  Z -> +
41        Dictionary<char, char> figuresToChar = new Dictionary<char, char>();
42
43        //List that contains a trace of the encrypt
44        List<string> trace;
45
46        #endregion
47
48        public Wheel[] ChiWheels
49        {
50            get { return chiWheels; }
51            set { chiWheels = value; }
52        }
53
54        public Wheel[] PsiWheels
55        {
56            get { return psiWheels; }
57            set { psiWheels = value; }
58        }
59
60        public Wheel[] MuWheels
61        {
62            get { return muWheels; }
63            set { muWheels = value; }
64        }
65
66        public Dictionary<char, string> BaudotCode
67        {
68            get { return baudotCode; }
69        }
70
71        public Dictionary<string, char> CharCode
72        {
73            get { return charCode; }
74        }
75
76        /// <summary>
77        /// Public property of the trace
78        /// </summary>
79        public List<string> Trace
80        {
81            get { return trace; }
82            set { trace = value; }
83        }
84
85        public bool TheresLimitation
86        {
87            get { return theresLimitation; }
88            set { theresLimitation = value; }
89        }
90
91        /// <summary>
92        /// The constructor where the
93        /// badout code's dictionary is
94        /// initialized
95        /// </summary>
96        public SZ42()
97        {
98            trace = new List<string>();
99
100            #region Baudot Code
101
102            baudotCode.Add('/', ".....");
103            baudotCode.Add('.', "..x..");
104            baudotCode.Add('H', "..x.x");
105            baudotCode.Add('T', "....x");
106            baudotCode.Add('O', "...xx");
107            baudotCode.Add('M', "..xxx");
108            baudotCode.Add('N', "..xx.");
109            baudotCode.Add('3', "...x.");
110            baudotCode.Add('R', ".x.x.");
111            baudotCode.Add('C', ".xxx.");
112            baudotCode.Add('V', ".xxxx");
113            baudotCode.Add('G', ".x.xx");
114            baudotCode.Add('L', ".x..x");
115            baudotCode.Add('P', ".xx.x");
116            baudotCode.Add('I', ".xx..");
117            baudotCode.Add('4', ".x...");
118            baudotCode.Add('A', "xx...");
119            baudotCode.Add('U', "xxx..");
120            baudotCode.Add('Q', "xxx.x");
121            baudotCode.Add('W', "xx..x");
122            baudotCode.Add('+', "xx.xx");
123            baudotCode.Add('-', "xxxxx");
124            baudotCode.Add('K', "xxxx.");
125            baudotCode.Add('J', "xx.x.");
126            baudotCode.Add('D', "x..x.");
127            baudotCode.Add('F', "x.xx.");
128            baudotCode.Add('X', "x.xxx");
129            baudotCode.Add('B', "x..xx");
130            baudotCode.Add('Z', "x...x");
131            baudotCode.Add('Y', "x.x.x");
132            baudotCode.Add('S', "x.x..");
133            baudotCode.Add('E', "x....");
134
135            #endregion
136
137            #region Characters Code
138
139            charCode.Add(".....", '/');
140            charCode.Add("..x..", '.');
141            charCode.Add("..x.x", 'H');
142            charCode.Add("....x", 'T');
143            charCode.Add("...xx", 'O');
144            charCode.Add("..xxx", 'M');
145            charCode.Add("..xx.", 'N');
146            charCode.Add("...x.", '3');
147            charCode.Add(".x.x.", 'R');
148            charCode.Add(".xxx.", 'C');
149            charCode.Add(".xxxx", 'V');
150            charCode.Add(".x.xx", 'G');
151            charCode.Add(".x..x", 'L');
152            charCode.Add(".xx.x", 'P');
153            charCode.Add(".xx..", 'I');
154            charCode.Add(".x...", '4');
155            charCode.Add("xx...", 'A');
156            charCode.Add("xxx..", 'U');
157            charCode.Add("xxx.x", 'Q');
158            charCode.Add("xx..x", 'W');
159            charCode.Add("xx.xx", '+');
160            charCode.Add("xxxxx", '-');
161            charCode.Add("xxxx.", 'K');
162            charCode.Add("xx.x.", 'J');
163            charCode.Add("x..x.", 'D');
164            charCode.Add("x.xx.", 'F');
165            charCode.Add("x.xxx", 'X');
166            charCode.Add("x..xx", 'B');
167            charCode.Add("x...x", 'Z');
168            charCode.Add("x.x.x", 'Y');
169            charCode.Add("x.x..", 'S');
170            charCode.Add("x....", 'E');
171
172            #endregion
173
174            #region Char To Figures
175
176            charToFigures.Add('ε', 'H');
177            charToFigures.Add('5', 'T');
178            charToFigures.Add('9', 'O');
179            charToFigures.Add('.', 'M');
180            charToFigures.Add(',', 'N');
181            charToFigures.Add('4', 'R');
182            charToFigures.Add(':', 'C');
183            charToFigures.Add('=', 'V');
184            charToFigures.Add('@', 'G');
185            charToFigures.Add(')', 'L');
186            charToFigures.Add('0', 'P');
187            charToFigures.Add('8', 'I');
188            charToFigures.Add('-', 'A');
189            charToFigures.Add('7', 'U');
190            charToFigures.Add('1', 'Q');
191            charToFigures.Add('2', 'W');
192            charToFigures.Add('(', 'k');
193            //figures.Add('ring bell', 'J');
194            //figures.Add('Who are you?', 'D');
195            charToFigures.Add('%', 'F');
196            charToFigures.Add('/', 'X');
197            charToFigures.Add('?', 'B');
198            charToFigures.Add('+', 'Z');
199            charToFigures.Add('6', 'Y');
200            charToFigures.Add('\'', 'S');
201            charToFigures.Add('3', 'E');
202           
203            #endregion
204
205            #region Figures To Char
206
207            figuresToChar.Add('H','ε');
208            figuresToChar.Add('T','5');
209            figuresToChar.Add('O','9');
210            figuresToChar.Add('M','.');
211            figuresToChar.Add('N',',');
212            figuresToChar.Add('R','4');
213            figuresToChar.Add('C',':');
214            figuresToChar.Add('V','=');
215            figuresToChar.Add('G','@');
216            figuresToChar.Add('L',')');
217            figuresToChar.Add('P','0');
218            figuresToChar.Add('I','8');
219            figuresToChar.Add('A','-');
220            figuresToChar.Add('U','7');
221            figuresToChar.Add('Q','1');
222            figuresToChar.Add('W','2');
223            figuresToChar.Add('k','(');
224            //figuresToChar('ring bell', 'J');
225            //figuresToChar('Who are you?', 'D');                   
226            figuresToChar.Add('F','%');
227            figuresToChar.Add('X','/');
228            figuresToChar.Add('B','?');
229            figuresToChar.Add('Z','+');
230            figuresToChar.Add('Y','6');
231            figuresToChar.Add('S','\'');
232            figuresToChar.Add('E','3');
233
234            #endregion
235
236            #region Wheels
237
238            chiWheels = new Wheel[] { 
239                                        new Wheel ("χ1", 41),
240                                        new Wheel ("χ2", 31),
241                                        new Wheel ("χ3", 29),
242                                        new Wheel ("χ4", 26),
243                                        new Wheel ("χ5", 23),
244                                    };
245           
246            psiWheels = new Wheel[] {                     
247                                        new Wheel ("Ψ1", 43),
248                                        new Wheel ("Ψ2", 47),
249                                        new Wheel ("Ψ3", 51),
250                                        new Wheel ("Ψ4", 53),
251                                        new Wheel ("Ψ5", 59)
252                                    };
253           
254            muWheels = new Wheel[] {       
255                                        new Wheel ("μ61", 61),
256                                        new Wheel ("μ37", 37)
257                                   };
258            #endregion
259
260            theresLimitation = true;
261
262            //Chi2 ONE BACK for the limitation
263            limitation = chiWheels[1].ActiveState;
264
265            //the earlier active position of the mu37
266            //for the basic motor character
267            basicMotor = muWheels[1].ActiveState;
268        }
269
270        public string ParseOutput(string raw) 
271        {
272            bool beginFig = false;
273            int i = 0;
274
275            raw = raw.Replace('.', ' ').Replace('3', '\r').Replace('4', '\n');
276
277            while (i < raw.Length)
278            {
279                if (raw[i] == '+')
280                {
281                    raw = raw.Remove(i, 1);
282                    beginFig = true;
283                }
284                else if (raw[i] == '-')
285                {
286                    beginFig = false;
287                    raw = raw.Remove(i, 1);
288                }
289               
290                if (beginFig)
291                {
292                    raw = raw.Insert(i, figuresToChar[raw[i]].ToString());
293                    raw = raw.Remove(i + 1, 1);
294                }
295
296                i++;
297            }
298
299            raw = raw.ToLower();
300
301            return raw;
302        }
303
304        /// <summary>
305        /// Parse the input
306        /// </summary>
307        public string ParseInput(string raw) 
308        {
309            bool beginFig = true;
310            int i = 0;
311            char temp;
312           
313            while(i < raw.Length)
314            {
315                if(charToFigures.ContainsKey(raw[i]))
316                {
317                    if (beginFig)
318                    {
319                        raw = raw.Insert(i, "+");
320                        i++;
321                        beginFig = false;
322                    }
323
324                    raw = raw.Insert(i, charToFigures[raw[i]].ToString());
325                    raw = raw.Remove(i + 1, 1);
326                   
327                    if (i == raw.Length - 1) 
328                    {
329                        temp = raw[i];
330                        raw = raw.Remove(i, 1);
331                        raw = raw.Insert(i, temp + "-");
332                        i++;
333                    }
334                }
335
336                if (!(i ==  raw.Length - 1))
337                {
338                    if (!beginFig && !charToFigures.ContainsKey(raw[i + 1]))
339                    {
340                        temp = raw[i];
341                        raw = raw.Remove(i, 1);
342                        raw = raw.Insert(i, temp + "-");
343                        i++;
344                        beginFig = true;
345                    }
346                }
347                i++;
348            }
349
350            raw = raw.ToUpper().Replace(' ', '.').Replace('\r', '3').Replace('\n', '4');
351
352            return raw;           
353        }
354
355        /// <summary>
356        /// Encrypt or Decrypt the string p
357        /// </summary>
358        public string ActionMachine(string p) 
359        {
360            string z = "";
361
362            foreach (char c in p) 
363            {
364                if (baudotCode.ContainsKey(c))
365                {
366                    z += SumBaudot(baudotCode[c], Character(chiWheels), Character(psiWheels));
367
368                    MoveWheels();
369                }
370                else
371                    z += c;
372            }
373                     
374            return z;
375        }
376   
377        /// <summary>
378        /// with char1 and char2 returns the character
379        /// that is generated by the XOR
380        /// </summary>
381        public char SumXOR(char char1, char char2)
382        {
383            char c;
384            string b = "", string1, string2;
385
386            string1 = baudotCode[char1];
387            string2 = baudotCode[char2];
388
389            for (int i = 0; i < 5; i++)
390                b += XOR(string1[i], string2[i]);
391
392            c = charCode[b];
393
394            return c;
395        }
396
397        /// <summary>
398        /// Controls the movement of the wheels
399        /// in every step (when a each p character is enciphered)
400        /// </summary>
401        private void MoveWheels()
402        {
403            if(theresLimitation)
404                //Chi2 ONE BACK for the limitation
405                limitation = chiWheels[1].ActiveState;
406
407            //Chiwheel move once
408            foreach (Wheel chi in chiWheels)
409                chi.MoveOnce();
410
411            if (muWheels[0].ActiveState == 'x')
412                muWheels[1].MoveOnce();
413
414            //Mu61 move once
415            muWheels[0].MoveOnce();
416
417            //Determine if the psiwheels step once
418            if (totalMotor == 'x')
419                foreach (Wheel psi in psiWheels)
420                    psi.MoveOnce();
421
422            basicMotor = muWheels[1].ActiveState;
423
424            //Find the Total Motor
425            if (theresLimitation)               
426                totalMotor = Conjunction(basicMotor, limitation);
427            else
428                totalMotor = basicMotor;
429        }
430
431        private char Conjunction(char bm, char lim)
432        {
433            if (bm == '.' & lim == 'x')
434                return '.';
435            else
436                return 'x';
437        }
438
439        /// <summary>
440        /// returns the character corresponding
441        /// to active position of a set of wheels
442        /// for example chiwheels
443        /// </summary>
444        private string Character(Wheel [] currentWheels) 
445        {
446            string badout = "";
447
448            foreach (Wheel wheel in currentWheels)
449                badout += wheel.ActiveState;
450
451            return badout;
452        }
453
454        /// <summary>
455        /// Returns a character corresponding to z
456        /// from the sum of p, chi and psi
457        /// </summary>
458        private char SumBaudot(string pstream, string chistream, string psistream) 
459        {
460            char c;
461            string b = "";
462
463            for (int i = 0; i < pstream.Length; i++)
464                b += XOR(pstream[i], XOR(chistream[i], psistream[i]));
465           
466            c = charCode[b];
467
468            trace.Add(charCode[pstream] + "    +    " + SumXOR(charCode[chistream], charCode[psistream]) + "    ->    " + c);
469
470            return c;
471        }
472
473        /// <summary>
474        /// Returns the results of to apply
475        /// XOR to two characters
476        /// </summary>
477        private char XOR(char op1, char op2) 
478        {
479            if (op1 == '.' && op2 == '.' || op1 == 'x' && op2 == 'x')
480                return '.';
481
482            if (op1 == '.' && op2 == 'x' || op2 == '.' && op1 == 'x')
483                return 'x';
484
485            return ' ';
486        }
487    }
488}
Note: See TracBrowser for help on using the repository browser.