source: trunk/CrypPlugins/T-310/T310.cs @ 2310

Last change on this file since 2310 was 2310, checked in by Matthäus Wander, 11 years ago

Consolidating x64 and x86 build targets. Please use only "x86", see #172.

override-bad-extension: Bdev.Net.Dns.dll
override-bad-extension: Bootstrapper.dll
override-bad-extension: Bootstrapper.pdb
override-bad-extension: CertificateLibrary.dll
override-bad-extension: CertificateLibrary.pdb
override-bad-extension: CertServices.dll
override-bad-extension: CertServices.pdb
override-bad-extension: Chord.dll
override-bad-extension: Chord.pdb
override-bad-extension: FullMeshDHT.dll
override-bad-extension: FullMeshDHT.pdb
override-bad-extension: FullMeshOverlay.dll
override-bad-extension: FullMeshOverlay.pdb
override-bad-extension: Gears4Net.dll
override-bad-extension: Gears4Net.pdb
override-bad-extension: LinkManager.dll
override-bad-extension: LinkManager.pdb
override-bad-extension: log4net.dll
override-bad-extension: log4net.pdb
override-bad-extension: msieve.dll
override-bad-extension: MySQLDHT.dll
override-bad-extension: MySQLDHT.pdb
override-bad-extension: NativeCryptography.dll
override-bad-extension: PapsClient.dll
override-bad-extension: PapsClient.pdb
override-bad-extension: PeersAtPlayBase.dll
override-bad-extension: PeersAtPlayBase.pdb
override-bad-extension: RUDP.dll
override-bad-extension: RUDP.pdb
override-bad-extension: Stun.dll
override-bad-extension: Stun.pdb
override-bad-extension: Util.dll
override-bad-extension: Util.pdb
override-bad-extension: WebDHT.dll
override-bad-extension: WebDHT.pdb
override-bad-extension: AnotherEditor.dll
override-bad-extension: CrypWin.exe

File size: 40.2 KB
Line 
1/*
2   Copyright 1995 - 2010 Jörg Drobick
3   Copyright 2010 Matthäus Wander, University of Duisburg-Essen
4
5   Licensed under the Apache License, Version 2.0 (the "License");
6   you may not use this file except in compliance with the License.
7   You may obtain a copy of the License at
8
9       http://www.apache.org/licenses/LICENSE-2.0
10
11   Unless required by applicable law or agreed to in writing, software
12   distributed under the License is distributed on an "AS IS" BASIS,
13   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   See the License for the specific language governing permissions and
15   limitations under the License.
16*/
17using System;
18using System.Collections.Generic;
19using System.Linq;
20using System.Text;
21using System.Windows;
22using Cryptool.PluginBase;
23using System.ComponentModel;
24using Cryptool.PluginBase.IO;
25using Cryptool.PluginBase.Miscellaneous;
26using System.ComponentModel;
27using System.Windows.Controls;
28using Cryptool.PluginBase.Cryptography;
29using System.IO;
30
31namespace Cryptool.Plugins.T310
32{
33    // TODO: shall use CryptoolStream respectively new CStream instead of byte[]
34    [Author("Jörg Drobick, Matthäus Wander", "wander@cryptool.org", "", "")]
35    [PluginInfo(false, "T-310/50", "East German Cipher Machine", null, "CrypWin/images/default.png")]
36    [EncryptionType(EncryptionType.Classic)]
37    public class T310 : IEncryption
38    {
39        #region Private Variables
40
41        private readonly T310Settings settings = new T310Settings();
42        private Random rand = new Random();
43
44        #endregion
45
46        #region Data Properties
47
48        [PropertyInfo(Direction.InputData, "Input data", "Enter plaintext (for encryption) or ciphertext (for decryption)", null)]
49        public byte[] InputData
50        {
51            get;
52            set;
53        }
54
55        [PropertyInfo(Direction.InputData, "Key", "Enter key as binary data", null, false, false, QuickWatchFormat.Hex, null)]
56        public byte[] InputKey
57        {
58            get;
59            set;
60        }
61
62        [PropertyInfo(Direction.OutputData, "Output data", "Resulting ciphertext (when encrypting) or plaintext (when decrypting)", null)]
63        public byte[] OutputData
64        {
65            get;
66            set;
67        }
68
69        [PropertyInfo(Direction.OutputData, "Key", "The key being used in binary", null)]
70        public byte[] OutputKey
71        {
72            get;
73            set;
74        }
75
76        #endregion
77
78        #region IPlugin Members
79
80        public ISettings Settings
81        {
82            get { return settings; }
83        }
84
85        public UserControl Presentation
86        {
87            get { return null; }
88        }
89
90        public UserControl QuickWatchPresentation
91        {
92            get { return null; }
93        }
94
95        public void PreExecution()
96        {
97        }
98
99        public void Execute()
100        {
101            bool[] s1_bit, s2_bit;
102            byte[] keyBinary;
103
104            ProgressChanged(0, 1);
105
106            if (InputKey != null && InputKey.Length > 0)
107            {
108                keyBinary = InputKey;
109            }
110            else
111            {
112                GuiLogMessage("No input key given, generating new one", NotificationLevel.Debug);
113                keyBinary = generateKey();
114            }
115
116            if (!KeyCheck(keyBinary, out s1_bit, out s2_bit))
117            {
118                GuiLogMessage("Invalid key", NotificationLevel.Error);
119                return;
120            }
121
122            OutputKey = keyBinary;
123            OnPropertyChanged("OutputKey");
124
125            if (settings.Mode == ModeEnum.Encrypt)
126            {
127                encrypt(InputData, ref s1_bit, ref s2_bit);
128            }
129            else
130            {
131                decrypt(InputData, ref s1_bit, ref s2_bit);
132            }
133
134            ProgressChanged(1, 1);
135        }
136
137        /* Schlüsselkarte erzeugen */
138        private byte[] generateKey()
139        {
140            byte[] keyBinary = new byte[30];
141            uint ui_Keycheck;
142
143            do
144            {
145                keyBinary[0] = (byte)rand.Next(255);
146                keyBinary[1] = (byte)rand.Next(255);
147                keyBinary[2] = (byte)rand.Next(255);
148                ui_Keycheck = (uint) keyBinary[2];
149                ui_Keycheck <<= 8;
150                ui_Keycheck += (uint) keyBinary[1];
151                ui_Keycheck <<= 8;
152                ui_Keycheck += (uint) keyBinary[0];
153            } while (!KeyParity(ui_Keycheck));
154            do
155            {
156                keyBinary[3] = (byte)rand.Next(255);
157                keyBinary[4] = (byte)rand.Next(255);
158                keyBinary[5] = (byte)rand.Next(255);
159                ui_Keycheck = (uint)keyBinary[5];
160                ui_Keycheck <<= 8;
161                ui_Keycheck += (uint)keyBinary[4];
162                ui_Keycheck <<= 8;
163                ui_Keycheck += (uint)keyBinary[3];
164            } while (!KeyParity(ui_Keycheck));
165            do
166            {
167                keyBinary[6] = (byte)rand.Next(255);
168                keyBinary[7] = (byte)rand.Next(255);
169                keyBinary[8] = (byte)rand.Next(255);
170                ui_Keycheck = (uint)keyBinary[8];
171                ui_Keycheck <<= 8;
172                ui_Keycheck += (uint)keyBinary[7];
173                ui_Keycheck <<= 8;
174                ui_Keycheck += (uint)keyBinary[6];
175            } while (!KeyParity(ui_Keycheck));
176            do
177            {
178                keyBinary[9] = (byte)rand.Next(255);
179                keyBinary[10] = (byte)rand.Next(255);
180                keyBinary[11] = (byte)rand.Next(255);
181                ui_Keycheck = (uint)keyBinary[11];
182                ui_Keycheck <<= 8;
183                ui_Keycheck += (uint)keyBinary[10];
184                ui_Keycheck <<= 8;
185                ui_Keycheck += (uint)keyBinary[9];
186            } while (!KeyParity(ui_Keycheck));
187            do
188            {
189                keyBinary[12] = (byte)rand.Next(255);
190                keyBinary[13] = (byte)rand.Next(255);
191                keyBinary[14] = (byte)rand.Next(255);
192                ui_Keycheck = (uint)keyBinary[14];
193                ui_Keycheck <<= 8;
194                ui_Keycheck += (uint)keyBinary[13];
195                ui_Keycheck <<= 8;
196                ui_Keycheck += (uint)keyBinary[12];
197            } while (!KeyParity(ui_Keycheck));
198
199            do
200            {
201                keyBinary[15] = (byte)rand.Next(255);
202                keyBinary[16] = (byte)rand.Next(255);
203                keyBinary[17] = (byte)rand.Next(255);
204                ui_Keycheck = (uint)keyBinary[17];
205                ui_Keycheck <<= 8;
206                ui_Keycheck += (uint)keyBinary[16];
207                ui_Keycheck <<= 8;
208                ui_Keycheck += (uint)keyBinary[15];
209            } while (!KeyParity(ui_Keycheck));
210            do
211            {
212                keyBinary[18] = (byte)rand.Next(255);
213                keyBinary[19] = (byte)rand.Next(255);
214                keyBinary[20] = (byte)rand.Next(255);
215                ui_Keycheck = (uint)keyBinary[20];
216                ui_Keycheck <<= 8;
217                ui_Keycheck += (uint)keyBinary[19];
218                ui_Keycheck <<= 8;
219                ui_Keycheck += (uint)keyBinary[18];
220            } while (!KeyParity(ui_Keycheck));
221            do
222            {
223                keyBinary[21] = (byte)rand.Next(255);
224                keyBinary[22] = (byte)rand.Next(255);
225                keyBinary[23] = (byte)rand.Next(255);
226                ui_Keycheck = (uint)keyBinary[23];
227                ui_Keycheck <<= 8;
228                ui_Keycheck += (uint)keyBinary[22];
229                ui_Keycheck <<= 8;
230                ui_Keycheck += (uint)keyBinary[21];
231            } while (!KeyParity(ui_Keycheck));
232            do
233            {
234                keyBinary[24] = (byte)rand.Next(255);
235                keyBinary[25] = (byte)rand.Next(255);
236                keyBinary[26] = (byte)rand.Next(255);
237                ui_Keycheck = (uint)keyBinary[26];
238                ui_Keycheck <<= 8;
239                ui_Keycheck += (uint)keyBinary[25];
240                ui_Keycheck <<= 8;
241                ui_Keycheck += (uint)keyBinary[24];
242            } while (!KeyParity(ui_Keycheck));
243            do
244            {
245                keyBinary[27] = (byte)rand.Next(255);
246                keyBinary[28] = (byte)rand.Next(255);
247                keyBinary[29] = (byte)rand.Next(255);
248                ui_Keycheck = (uint)keyBinary[29];
249                ui_Keycheck <<= 8;
250                ui_Keycheck += (uint)keyBinary[28];
251                ui_Keycheck <<= 8;
252                ui_Keycheck += (uint)keyBinary[27];
253            } while (!KeyParity(ui_Keycheck));
254
255            return keyBinary;
256
257//            string s_Kenngruppe = "";
258//            for (byte b_FsKg = 0; b_FsKg < 5; ++b_FsKg)
259//            {
260//                byte b_FsRand = 0;
261//                do
262//                {
263//                    b_FsRand = (byte)(0x1f & (byte)rand_myZufall.Next());
264//                } while (b_FsRand > 0x18);
265//                s_Kenngruppe += (char)(0x61 + b_FsRand);
266//            }
267//            mTB_Kenngruppe.Text = s_Kenngruppe;
268        }
269
270        private bool KeyCheck(byte[] keyBinary, out bool[] s1_bit, out bool[] s2_bit)
271        {
272            s1_bit = new bool[120];
273            s2_bit = new bool[120];
274
275            uint[] key1Quinary = new uint[5];
276            uint[] key2Quinary = new uint[5];
277
278            uint i_Keycheck = (uint) keyBinary[2];
279            i_Keycheck <<= 8;
280            i_Keycheck += (uint) keyBinary[1];
281            i_Keycheck <<= 8;
282            i_Keycheck += (uint) keyBinary[0];
283            if (!KeyParity(i_Keycheck)) return false;
284            key1Quinary[0] = i_Keycheck;
285            // anzahl der 1 "H" ungerade!
286            i_Keycheck = (uint) keyBinary[5];
287            i_Keycheck <<= 8;
288            i_Keycheck += (uint) keyBinary[4];
289            i_Keycheck <<= 8;
290            i_Keycheck += (uint) keyBinary[3];
291            if (!KeyParity(i_Keycheck)) return false;
292            // anzahl der 1 "H" ungerade!
293            key1Quinary[1] = i_Keycheck;
294            i_Keycheck = (uint) keyBinary[8];
295            i_Keycheck <<= 8;
296            i_Keycheck += (uint) keyBinary[7];
297            i_Keycheck <<= 8;
298            i_Keycheck += (uint) keyBinary[6];
299            if (!KeyParity(i_Keycheck)) return false;
300            // anzahl der 1 "H" ungerade!
301            key1Quinary[2] = i_Keycheck;
302            i_Keycheck = (uint) keyBinary[11];
303            i_Keycheck <<= 8;
304            i_Keycheck += (uint) keyBinary[10];
305            i_Keycheck <<= 8;
306            i_Keycheck += (uint) keyBinary[9];
307            if (!KeyParity(i_Keycheck)) return false;
308            // anzahl der 1 "H" ungerade!
309            key1Quinary[3] = i_Keycheck;
310            i_Keycheck = (uint) keyBinary[14];
311            i_Keycheck <<= 8;
312            i_Keycheck += (uint) keyBinary[13];
313            i_Keycheck <<= 8;
314            i_Keycheck += (uint) keyBinary[12];
315            if (!KeyParity(i_Keycheck)) return false;
316            // anzahl der 1 "H" ungerade!
317            key1Quinary[4] = i_Keycheck;
318            S_fuellen(ref s1_bit, key1Quinary[0], 1, 1);
319            S_fuellen(ref s1_bit, key1Quinary[1], 1, 2);
320            S_fuellen(ref s1_bit, key1Quinary[2], 1, 3);
321            S_fuellen(ref s1_bit, key1Quinary[3], 1, 4);
322            S_fuellen(ref s1_bit, key1Quinary[4], 1, 5);
323            i_Keycheck = (uint) keyBinary[17];
324            i_Keycheck <<= 8;
325            i_Keycheck += (uint) keyBinary[16];
326            i_Keycheck <<= 8;
327            i_Keycheck += (uint) keyBinary[15];
328            if (!KeyParity(i_Keycheck)) return false;
329            // anzahl der 1 "H" ungerade!
330            key2Quinary[0] = i_Keycheck;
331            i_Keycheck = (uint) keyBinary[20];
332            i_Keycheck <<= 8;
333            i_Keycheck += (uint) keyBinary[19];
334            i_Keycheck <<= 8;
335            i_Keycheck += (uint) keyBinary[18];
336            if (!KeyParity(i_Keycheck)) return false;
337            // anzahl der 1 "H" ungerade!
338            key2Quinary[1] = i_Keycheck;
339            i_Keycheck = (uint) keyBinary[23];
340            i_Keycheck <<= 8;
341            i_Keycheck += (uint) keyBinary[22];
342            i_Keycheck <<= 8;
343            i_Keycheck += (uint) keyBinary[21];
344            if (!KeyParity(i_Keycheck)) return false;
345            // anzahl der 1 "H" ungerade!
346            key2Quinary[2] = i_Keycheck;
347            i_Keycheck = (uint) keyBinary[26];
348            i_Keycheck <<= 8;
349            i_Keycheck += (uint) keyBinary[25];
350            i_Keycheck <<= 8;
351            i_Keycheck += (uint) keyBinary[24];
352            if (!KeyParity(i_Keycheck)) return false;
353            // anzahl der 1 "H" ungerade!
354            key2Quinary[3] = i_Keycheck;
355            i_Keycheck = (uint) keyBinary[29];
356            i_Keycheck <<= 8;
357            i_Keycheck += (uint) keyBinary[28];
358            i_Keycheck <<= 8;
359            i_Keycheck += (uint) keyBinary[27];
360            if (!KeyParity(i_Keycheck)) return false;
361            // anzahl der 1 "H" ungerade!
362            key2Quinary[4] = i_Keycheck;
363            S_fuellen(ref s2_bit, key2Quinary[0], 1, 1);
364            S_fuellen(ref s2_bit, key2Quinary[1], 1, 2);
365            S_fuellen(ref s2_bit, key2Quinary[2], 1, 3);
366            S_fuellen(ref s2_bit, key2Quinary[3], 1, 4);
367            S_fuellen(ref s2_bit, key2Quinary[4], 1, 5);
368//            if (mTB_Kenngruppe.Text.Length < 5) return false;
369//            for (byte b_text = 0; b_text < 5; ++b_text)
370//                if ((mTB_Kenngruppe.Text[b_text] > 0x7a) || (mTB_Kenngruppe.Text[b_text] < 0x61))
371//                {                                     // wenn kleiner 'A' oder größer 'Z'
372//                    mTB_Kenngruppe.Clear();
373//                    return false;
374//                }
375            return true;
376        }
377
378        /* Key1-5, 6-10 ... ungerade */
379        private bool KeyParity(uint i_TeilKey)
380        {
381            int i_shiftRegister = 1;                         // Maske
382            bool bo_MaskSum = false;                         // speichern des Zwischenergebnisses
383
384            for (byte b_count = 0; b_count < 24; ++b_count)  // die 24 bit des Schlüssels
385            {
386                if ((i_TeilKey & i_shiftRegister) > 0)      //Schlüsselbit AND Maske
387                {
388                    if (bo_MaskSum)                         // war das erbnis schon true?  ( XOR Funktion einmal anders )
389                        bo_MaskSum = false;
390                    else
391                        bo_MaskSum = true;
392                }
393                i_shiftRegister <<= 1;                       // schieben der Maske in die entsprechende Position
394            }
395            return bo_MaskSum;
396        }
397
398        /* S1 und S2 Bitfeld füllen */
399        private void S_fuellen(ref bool[] keyBits, uint ui_Teilschluessel, byte b_Snummer, byte b_Teilnr)
400        {
401            byte b_index;
402            int i_temp;
403            uint ui_schiebe = 1;
404
405            for (b_index = 0; b_index < 24; ++b_index)
406            {
407                i_temp = (b_Teilnr - 1) * 24 + b_index;
408                keyBits[i_temp] = (ui_Teilschluessel & ui_schiebe) > 0 ? true : false;
409                ui_schiebe <<= 1;
410            }
411        }
412
413        private void encrypt(byte[] by_array_eingabe, ref bool[] s1_bit, ref bool[] s2_bit)
414        {
415            using (MemoryStream streamAusgabe = new MemoryStream())
416            {
417                for (byte temp = 0; temp < 4; ++temp)
418                {
419                    streamAusgabe.WriteByte(0x19);    // 4*b
420                }
421                /* Speicher erste Zufallsfolge der Synchronfolge */
422                ulong ul_temp = Zufall();                  // Speicher Random-folge
423                ulong ul_lese = ul_temp;
424                for (byte temp = 0; temp < 8; ++temp)
425                {
426
427                    byte b_lese;
428                    b_lese = (byte)(ul_lese & 0xff);                   // nur das erste Byte lesen
429                    streamAusgabe.WriteByte(b_lese);                   // speichern
430                    ul_lese = ul_lese >> 8;                            // nächsten 8 bit holen
431                }
432                /* Speicher Synchronfolge*/
433                ulong ul_syncronfolge = Syncronfolge(ul_temp);
434                ul_lese = ul_syncronfolge;                             // hole Synchronfolge
435                for (byte temp = 0; temp < 8; ++temp)
436                {
437                    byte b_lese;
438                    b_lese = (byte)(ul_lese & 0xff);                   // nur das erste Byte lesen
439                    streamAusgabe.WriteByte(b_lese);                   // speichern
440                    ul_lese = ul_lese >> 8;                            // nächsten 8 bit holen
441                }
442                for (byte temp = 0; temp < 4; ++temp)
443                {
444                    streamAusgabe.WriteByte(0x0f);   // 4*k
445                }
446                bool[] bo_U_Vektor = UVektorInit();                                      // U-Vektor auf Anfang setzen!
447                // hier jetzt Klartext holen und Chiffrieren
448                int int_zaehler = 0;
449                byte b_temp, b_temp0;
450                //Thread.Sleep(200);
451                while (int_zaehler < (by_array_eingabe.Length - 1))
452                {
453                    System.Threading.Thread.Sleep(10);
454                    b_temp = (byte)((0xf8 & by_array_eingabe[int_zaehler]) >> 3);                   // byte No. 1
455                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));  // bit 7 ... 3
456
457                    b_temp = (byte)((0x07 & by_array_eingabe[int_zaehler]) << 2);                    // bit 2 ... 0
458                    ++int_zaehler;                                             // byte No. 2
459                    if (int_zaehler == by_array_eingabe.Length) int_zaehler = by_array_eingabe.Length - 1;
460                    b_temp |= (byte)(by_array_eingabe[int_zaehler] >> 6);                   // bit 7, 6
461                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
462
463                    b_temp = (byte)((0x3e & by_array_eingabe[int_zaehler]) >> 1);
464                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
465
466                    b_temp = (byte)((0x01 & by_array_eingabe[int_zaehler]) << 4);
467                    ++int_zaehler;                                              // byte No. 3
468                    if (int_zaehler == by_array_eingabe.Length) int_zaehler = by_array_eingabe.Length - 1;
469                    b_temp |= (byte)((0xf0 & by_array_eingabe[int_zaehler]) >> 4);
470                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
471
472                    b_temp = (byte)((0x0f & by_array_eingabe[int_zaehler]) << 1);
473                    ++int_zaehler;                                             // byte 4;
474                    if (int_zaehler == by_array_eingabe.Length) int_zaehler = by_array_eingabe.Length - 1;
475                    b_temp |= (byte)(by_array_eingabe[int_zaehler] >> 7);
476                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
477
478                    b_temp = (byte)((0x7c & by_array_eingabe[int_zaehler]) >> 2);
479                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
480
481                    b_temp = (byte)((0x03 & by_array_eingabe[int_zaehler]) << 3);
482                    ++int_zaehler;                                              // byte 5
483                    if (int_zaehler == by_array_eingabe.Length) int_zaehler = by_array_eingabe.Length - 1;
484                    b_temp |= (byte)((0xe0 & by_array_eingabe[int_zaehler]) >> 5);
485                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
486
487                    b_temp = (byte)(0x1f & by_array_eingabe[int_zaehler]);
488                    streamAusgabe.WriteByte(verschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), b_temp));
489                    ++int_zaehler;                                              // byte 6 erhöhe für schleif
490                    // Warten auf Anzeigenaktualisierung
491                    //                Application.DoEvents();
492                    // Progressbar anzeigen
493                    ProgressChanged(int_zaehler, by_array_eingabe.Length);
494                }
495
496                OutputData = streamAusgabe.ToArray();
497                OnPropertyChanged("OutputData");
498            }
499        }
500
501        private void decrypt(byte[] by_array_eingabe, ref bool[] s1_bit, ref bool[] s2_bit)
502        {
503            using (MemoryStream streamAusgabe = new MemoryStream())
504            {
505                ulong ul_startfolge = 0ul;
506                ulong ul_syncronfolge = 0ul;
507
508                if (by_array_eingabe.Length < 24 ||
509                !((by_array_eingabe[0] == 0x19) & (by_array_eingabe[1] == 0x19) & (by_array_eingabe[2] == 0x19) & (by_array_eingabe[3] == 0x19) & (by_array_eingabe[20] == 0x0f) & (by_array_eingabe[21] == 0x0f) & (by_array_eingabe[22] == 0x0f) & (by_array_eingabe[23] == 0x0f)))
510                {
511                    GuiLogMessage("Can't decrypt, invalid input sequence", NotificationLevel.Error);
512
513//                    pB_c.Visible = false;
514//                    MessageBox.Show();
515//                    bt_Loe_Click(sender, e);
516//                    streamAusgabe.Close();
517//                    button_action(true);
518
519                    return;
520                }
521
522                for (byte temp = 11; temp > 3; --temp)
523                {
524                    ul_startfolge <<= 8;
525                    ul_startfolge |= by_array_eingabe[temp];
526                }
527                for (byte temp = 19; temp > 11; --temp)
528                {
529                    ul_syncronfolge <<= 8;
530                    ul_syncronfolge |= by_array_eingabe[temp];
531                }
532                if (ul_syncronfolge != Syncronfolge(ul_startfolge))
533                {
534                    GuiLogMessage("Can't decrypt, invalid input sequence", NotificationLevel.Error);
535
536//                    pB_c.Visible = false;
537//                    MessageBox.Show("Synchronfolge falsch");
538//                    bt_Loe_Click(sender, e);
539//                    streamAusgabe.Close();
540//                    button_action(true);
541
542                    return;
543                }
544
545                //                    pB_c.Visible = true;
546
547                bool[] bo_U_Vektor = UVektorInit();                                      // U-Vektor auf Anfang setzen!
548
549                // hier jetzt Bytes holen und dechiffrieren
550                int int_ent = 24;
551                byte b_temp0, b_temp1, b_temp2, b_temp3, b_temp4, b_temp5, b_temp6, b_temp7;
552                while (int_ent < by_array_eingabe.Length - 1)
553                {
554                    b_temp0 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
555                    ++int_ent;
556                    b_temp1 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
557                    ++int_ent;
558                    b_temp2 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
559                    ++int_ent;
560                    b_temp3 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
561                    ++int_ent;
562                    b_temp4 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
563                    ++int_ent;
564                    b_temp5 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
565                    ++int_ent;
566                    b_temp6 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
567                    ++int_ent;
568                    b_temp7 = entschluesseln(Wurm(ref bo_U_Vektor, ref ul_syncronfolge, ref s1_bit, ref s2_bit), by_array_eingabe[int_ent]);
569                    ++int_ent;
570
571                    // ProgressBar anzeigen
572                    ProgressChanged(int_ent, by_array_eingabe.Length);
573
574                    b_temp0 <<= 3;
575                    b_temp0 |= (byte)((b_temp1 & 0x1c) >> 2); ;
576                    streamAusgabe.WriteByte(b_temp0);  // erstes Byte
577
578                    b_temp1 <<= 6;
579                    b_temp1 |= (byte)((b_temp2 << 1) | ((b_temp3 & 0x10) >> 4));
580                    streamAusgabe.WriteByte(b_temp1);  // zweites Byte
581
582                    b_temp3 <<= 4;
583                    b_temp3 |= (byte)((b_temp4 & 0x1e) >> 1);
584                    streamAusgabe.WriteByte(b_temp3);  // drittes Byte
585
586                    b_temp4 <<= 7;
587                    b_temp4 |= (byte)((b_temp6 >> 3) | (b_temp5 << 2));
588                    streamAusgabe.WriteByte(b_temp4);  // viertes Byte
589
590                    b_temp6 <<= 5;
591                    b_temp6 |= b_temp7;
592                    streamAusgabe.WriteByte(b_temp6);  // fünftes Byte
593                    //                            Application.DoEvents();
594                }
595                //                        bt_Loe_Click(sender, e);
596
597                OutputData = streamAusgabe.ToArray();
598                OnPropertyChanged("OutputData");
599            }
600        }
601
602        private ulong Zufall()
603        {
604            ulong ul_kg = 0;                                    // variable Kenngruppe
605            ulong ul_kg2 = 0;                                   // temporäre zweite Variable für Kenngruppe
606
607            while (ul_kg == 0ul)
608            {
609                ul_kg = (ulong)rand.Next();           // die ersten 32 bit
610                ul_kg *= 0x100000000ul;                        // Schift Left 32, "<<" nicht bei ULONG
611                ul_kg2 = (ulong)rand.Next();          // die nächsten 32 bit
612                // wegen Compiler Warnung so Programmiert, einfacher wäre: ul_kg |= (ulong)rand_myZufall.Next();
613                ul_kg |= ul_kg2;                               // die letzten 32 bit
614                ul_kg &= 0x1fffffffffffffff;                   // Maskieren auf 61 Bit
615            }                                                  // While Prüfen auf Ungleich NULL
616            return ul_kg;
617        }
618
619        private ulong Syncronfolge(ulong ul_Parameter)
620        {
621            bool bo_m2;                                                     // ergebnis des XOR bit 0,1,2,5
622
623            ulong ul_Output = (ul_Parameter & 0x1fffffffffffffff) >> 60;           // ul_Output vorbereiten für die nächsten 13 FsZeichen
624            // das 61 Bit holen es ist das erste bit des 13.Fs Zeichens
625            for (int int_i = 1; int_i < 65; ++int_i)
626            {
627                // Umformung durch Bit 0 xor 1 xor 2 xor 5
628
629                bo_m2 = ((ul_Parameter & 0x1ul) == 0ul ? false : true)
630                ^ ((ul_Parameter & 0x2ul) == 0ul ? false : true)
631                ^ ((ul_Parameter & 0x4ul) == 0ul ? false : true)
632                ^ ((ul_Parameter & 0x20ul) == 0ul ? false : true);
633
634                ul_Parameter >>= 1;                                              // Shift rechts 1, von 60 nach 0
635                ul_Output |= bo_m2 == true ? (0x1ul << int_i) : 0x0ul;               // entspricht Set/Reset Bit i, in der Position i
636                ul_Parameter |= bo_m2 == true ? 0x1000000000000000ul : 0x0ul;    // entspricht Set/Reset Bit 0
637                ul_Parameter &= 0x1fffffffffffffff;
638            }
639            return ul_Parameter;
640        }
641
642        /* U-Vektor initialisieren, immer beim Starten des Chiffrierens und Dechiffrierens */
643        private bool[] UVektorInit()
644        {
645            return new bool[37]{           // der U-Vektor ist die Startbedingung der 4bitigen schieberegister
646            false, false,true,true,false, true,false,false,
647            true, true,true,false,false, false,true,true, 
648            true, true,true,false,false, true,false,false,
649            false, false,true,false,true, true,false,true,
650            false, false,false,true,true };     // U-Vektor x0110 1001 1100 0111 1100 1000 0101 1010 0011, Startbedinung, u[0] wird nicht verwendet
651        }
652
653        /* Entschlüsselungroutine der T310, sie is kürzer als die Verschlüsselungsroutine
654         * Übergabe Wurm-,Additionsreihe gebildet aus der Synchronisationseinheit
655         * Übergabe Cryptogramm, Geheimtexteinheit
656         * Rückgabe Klartext
657         *************************************************************************************/
658        static byte entschluesseln(uint ui_key, byte b_crypt)
659        {
660            byte b_SRV2, b_SRV3;
661
662            b_SRV3 = b_crypt;
663            b_SRV2 = (byte)(ui_key & 0x1f);
664            while ((b_SRV2 != 0x1f) & (b_SRV2 != 0))  // Rekursion der Additionsreihe in SRV2 und des GTX in SRV3
665            {
666                b_SRV2 = Rekursion(b_SRV2);
667                b_SRV3 = Rekursion(b_SRV3);             // Z gebildet
668            }
669            b_SRV3 ^= (byte)((ui_key & 0x07c0) >> 6);   // (0x0f80)> 6; XOR Additionsreihe 7 ... 11 mit dem Zwischentext Z
670            return b_SRV3;
671        }     
672
673
674        /* Verschlüsselungsroutine der T310
675         * Übergabe Wurmreihe (Additionsreihe)
676         * Übergabe Klartext
677         * Rückgramme Cryptogram, Geheimtexteinheit
678         *******************************************/
679        static byte verschluesseln(uint ui_key, byte b_klartext)
680        {
681            byte b_SRV2, b_SRV3;
682
683            // Schritt 1 ... 5
684            //schieberegister aufbauen 
685            b_SRV2 = 0;
686            b_SRV3 = 0x01f;
687            int i_tempKey = (int)ui_key & 0x01f;  // bit 0 ... bit 4 == 1-5 des keys
688            b_SRV2 = (byte)i_tempKey;
689            // Schritt 1 ... 5
690
691            // Schritt 6
692            // symetriewert bilden, rekursion
693            while ((b_SRV2 != 0x1f) & (b_SRV2 != 0)) // wenn 11111 ( 0x1f oder 31 ) ODER 0 abbrechen
694            {                                          // Achtung das ODER ist hier über UNGLEICH UND realisiert
695                b_SRV2 = Rekursion(b_SRV2);
696                b_SRV3 = Rekursion(b_SRV3);
697            }
698            // Schritt 6  *****************************   Bit 6 bleibt ungenutzt!
699
700            // Schritt 7 ... 11
701            b_SRV2 = b_SRV3;                           // b_SRV3 nach b_SRV2 kopieren
702            i_tempKey = (int)(ui_key & 0x07c0) >> 6;   // bit 6 ... 10 == 7-11 des keys
703            b_SRV3 = (byte)i_tempKey;          // copy Bitt 7 ... 11 ins SRV3
704            b_SRV3 ^= b_klartext;                      // Additionsreihe 7 ... 11 XOR Ktxt (5bit)
705            // Schritt 7 ... 11
706
707            // Schritt 12  *****************************   Bit 12 bleibt ungenutzt!
708
709            // Schritt 13
710            while ((b_SRV2 != 0x1f) & (b_SRV2 != 0)) // wenn 11111 ( 0x1f oder 31 ) ODER 0 abbrechen
711            {
712                b_SRV2 = Rekursion(b_SRV2);
713                b_SRV3 = Rekursion(b_SRV3);
714            }
715            // Schritt 13
716
717            // Schritt 14; neues Zeichen holen und neue Schlüssel und beginn bei Schritt 1
718            return b_SRV3;   // Ausgabe Chiffriertext
719        }
720
721        /* Rekursionsregister 5 bit realisiert
722         * Übergabe Registerwert
723         * Rückgabe Rekursionsergebniss
724         ***********************************************/
725        static byte Rekursion(byte b_Register)
726        {
727            const byte b_Bit3 = 0x04;
728            const byte b_Bit5 = 0x10;
729            const byte b_5Bitmaske = 0x1f; // Bitmaske aller werte innerhalb von 0 ... 31
730
731            Boolean bo_xor = false;        // ergebnis des bitweisen XOR 
732
733            byte b_ret = b_Register;       // übergabe der Eingabe an das Ausgabebyte
734
735            bo_xor = ((b_Bit3 & b_ret) == 0 ? false : true) ^ ((b_Bit5 & b_ret) == 0 ? false : true);
736            b_ret <<= 1;                   // bo_XOR bildet rekusrionsbit aus Bit 1 und Bit 5
737            b_ret |= (byte)(bo_xor == true ? 0x01 : 0);
738            b_ret &= b_5Bitmaske;
739            return b_ret;
740        }
741
742        /* Schlüsselgenerator ablauf, Schrittkette, Automat, Batch, im Start-Stopp Betrieb */
743        private uint Wurm(ref bool[] bo_U_Vektor, ref ulong ul_syncronfolge, ref bool[] s1_bit, ref bool[] s2_bit)
744        {
745            byte b_fsBit = 0;
746            uint ui_wurmBit = 0;
747            uint ui_wurm = 0;
748            byte b_zeiger = 0;
749            bool[] bo_T = new bool[9]; // Bool Array der T-Funktion
750
751            while (b_fsBit < 13)
752            {   // 5 bit sammeln aus 127ten runde * bit des Fs Zeichen, 127 - 254 - 381 - 508 - 635 -neues FsZeichen 762 ...
753                for (byte b_runde = 0; b_runde < 127; ++b_runde)
754                {
755                    // knobel knobel
756                    // S1 und S2 Schieben
757                    bool bo_tempS1 = s1_bit[b_zeiger];
758                    bool bo_tempS2 = s2_bit[b_zeiger];
759
760
761                    // T-Funktion mit LSZ 31
762                    bo_T[0] = (ul_syncronfolge & 0x01) == 1 ? true : false;  // > 0 ?; hole Bit 0 aus der synchronfolge
763                    bo_T[1] = bo_T[0] ^ Z(bo_tempS2, bo_U_Vektor[7], bo_U_Vektor[4], bo_U_Vektor[33], bo_U_Vektor[30], bo_U_Vektor[18]);
764                    bo_T[2] = bo_T[1] ^ bo_U_Vektor[36];
765                    bo_T[3] = bo_T[2] ^ Z(bo_U_Vektor[5], bo_U_Vektor[35], bo_U_Vektor[9], bo_U_Vektor[16], bo_U_Vektor[23], bo_U_Vektor[26]);
766                    bo_T[4] = bo_T[3] ^ bo_U_Vektor[32];
767                    bo_T[5] = bo_T[4] ^ bo_U_Vektor[5] ^ Z(bo_U_Vektor[12], bo_U_Vektor[21], bo_U_Vektor[1], bo_U_Vektor[13], bo_U_Vektor[25], bo_U_Vektor[20]);
768                    bo_T[6] = bo_T[5] ^ bo_U_Vektor[8];
769                    bo_T[7] = bo_T[6] ^ Z(bo_U_Vektor[24], bo_U_Vektor[15], bo_U_Vektor[22], bo_U_Vektor[29], bo_U_Vektor[10], bo_U_Vektor[28]);
770                    bo_T[8] = bo_T[7] ^ bo_U_Vektor[6];
771
772                    // U-Vektoren schieben
773                    bo_U_Vektor[36] = bo_U_Vektor[35];
774                    bo_U_Vektor[35] = bo_U_Vektor[34];
775                    bo_U_Vektor[34] = bo_U_Vektor[33];
776                    bo_U_Vektor[33] = bo_U_Vektor[0] ^ bo_U_Vektor[19]; //  UD9;
777
778                    bo_U_Vektor[32] = bo_U_Vektor[31];
779                    bo_U_Vektor[31] = bo_U_Vektor[30];
780                    bo_U_Vektor[30] = bo_U_Vektor[29];
781                    bo_U_Vektor[29] = bo_U_Vektor[1] ^ bo_U_Vektor[35]; // UD8;
782
783                    bo_U_Vektor[28] = bo_U_Vektor[27];
784                    bo_U_Vektor[27] = bo_U_Vektor[26];
785                    bo_U_Vektor[26] = bo_U_Vektor[25];
786                    bo_U_Vektor[25] = bo_U_Vektor[2] ^ bo_U_Vektor[31]; //  UD7;
787
788                    bo_U_Vektor[24] = bo_U_Vektor[23];
789                    bo_U_Vektor[23] = bo_U_Vektor[22];
790                    bo_U_Vektor[22] = bo_U_Vektor[21];
791                    bo_U_Vektor[21] = bo_U_Vektor[3] ^ bo_U_Vektor[27]; //  UD6;
792
793                    bo_U_Vektor[20] = bo_U_Vektor[19];
794                    bo_U_Vektor[19] = bo_U_Vektor[18];
795                    bo_U_Vektor[18] = bo_U_Vektor[17];
796                    bo_U_Vektor[17] = bo_U_Vektor[4] ^ bo_U_Vektor[11]; // UD5;
797
798                    bo_U_Vektor[16] = bo_U_Vektor[15];
799                    bo_U_Vektor[15] = bo_U_Vektor[14];
800                    bo_U_Vektor[14] = bo_U_Vektor[13];
801                    bo_U_Vektor[13] = bo_U_Vektor[5] ^ bo_U_Vektor[23]; // UD4;
802
803                    bo_U_Vektor[12] = bo_U_Vektor[11];
804                    bo_U_Vektor[11] = bo_U_Vektor[10];
805                    bo_U_Vektor[10] = bo_U_Vektor[9];
806                    bo_U_Vektor[9] = bo_U_Vektor[6] ^ bo_U_Vektor[3];  // UD3;
807
808                    bo_U_Vektor[8] = bo_U_Vektor[7];
809                    bo_U_Vektor[7] = bo_U_Vektor[6];
810                    bo_U_Vektor[6] = bo_U_Vektor[5];
811                    bo_U_Vektor[5] = bo_U_Vektor[7] ^ bo_U_Vektor[15]; // UD2;
812
813                    bo_U_Vektor[4] = bo_U_Vektor[3];
814                    bo_U_Vektor[3] = bo_U_Vektor[2];
815                    bo_U_Vektor[2] = bo_U_Vektor[1];
816                    bo_U_Vektor[1] = bo_T[8] ^ bo_tempS1; // UD1 D = 0;
817                    // jetzt Kommutatorkarte abbilden 29 Eingänge > 58 Ausgänge
818
819                    // Zeiger auf nächstes Bit
820                    ++b_zeiger;
821                    if (b_zeiger > 119) b_zeiger = 0;   // Zeiger entspricht das rotieren des S1, S2 schlüssels
822                    rot_Ffolge(ref ul_syncronfolge); // rotiere F-Folge die Syncronfolge
823
824                } // 127 Runden!
825                ui_wurm = (uint)(bo_U_Vektor[23] == true ? 0x01 : 0x00);
826                ui_wurm <<= b_fsBit; // schiebe ergebnis in die entsprechende Bitstelle des FsBytes, Bit 0 bis bit 12
827                ui_wurmBit |= ui_wurm;      // Maskiere und setze gebildetes bit
828                ++b_fsBit;                    // nächstes bit
829            }
830            /* Abfrage später Löschen! */
831            if (ui_wurmBit > 0x1fff) MessageBox.Show("Fehler Komplizierungseinheit");
832            ui_wurmBit &= 0x1fff;         // Maskieren
833            return ui_wurmBit; // Rückgabe 13 bit Wurm
834        }
835
836        /* rotiere f-Folge */
837        private void rot_Ffolge(ref ulong ul_syncronfolge)
838        {
839            bool bo_m2;                                                     // ergebnis des XOR bit 0,1,2,5
840
841            // Umformung durch Bit 0 xor 1 xor 2 xor 5
842
843            bo_m2 = ((ul_syncronfolge & 0x1ul) == 0ul ? false : true)
844            ^ ((ul_syncronfolge & 0x2ul) == 0ul ? false : true)
845            ^ ((ul_syncronfolge & 0x4ul) == 0ul ? false : true)
846            ^ ((ul_syncronfolge & 0x20ul) == 0ul ? false : true);
847
848            ul_syncronfolge >>= 1;                                              // Shift rechts 1, von 60 nach 0
849            ul_syncronfolge |= bo_m2 == true ? 0x1000000000000000ul : 0x0ul;    // entspricht Set/Reset Bit 0
850            ul_syncronfolge &= 0x1fffffffffffffff;
851        }
852
853        /* Z-Funktion */
854        private bool Z(bool b_1, bool b_2, bool b_3, bool b_4, bool b_5, bool b_6)
855        {
856            bool bo_temp = true ^ b_1 ^ b_5 ^ b_6 ^ (b_1 && b_4);
857            bo_temp ^= (b_2 && b_3) ^ (b_2 && b_5) ^ (b_4 && b_5) ^ (b_5 && b_6);
858            bo_temp ^= (b_1 && b_3 && b_4) ^ (b_1 && b_3 && b_6) ^ (b_1 && b_4 && b_5);
859            bo_temp ^= (b_2 && b_3 && b_6) ^ (b_2 && b_4 && b_6) ^ (b_3 && b_5 && b_6);
860            bo_temp ^= (b_1 && b_2 && b_3 && b_4) ^ (b_1 && b_2 && b_3 && b_5);
861            bo_temp ^= (b_1 && b_2 && b_5 && b_6) ^ (b_2 && b_3 && b_4 && b_6);
862            bo_temp ^= (b_1 && b_2 && b_3 && b_4 && b_5) ^ (b_1 && b_3 && b_4 && b_5 && b_6);
863            return (bo_temp);
864        }
865
866        public void PostExecution()
867        {
868        }
869
870        public void Pause()
871        {
872        }
873
874        public void Stop()
875        {
876        }
877
878        public void Initialize()
879        {
880        }
881
882        public void Dispose()
883        {
884        }
885
886        #endregion
887
888        #region Event Handling
889
890        public event StatusChangedEventHandler OnPluginStatusChanged;
891
892        public event GuiLogNotificationEventHandler OnGuiLogNotificationOccured;
893
894        public event PluginProgressChangedEventHandler OnPluginProgressChanged;
895
896        public event PropertyChangedEventHandler PropertyChanged;
897
898        private void GuiLogMessage(string message, NotificationLevel logLevel)
899        {
900            EventsHelper.GuiLogMessage(OnGuiLogNotificationOccured, this, new GuiLogEventArgs(message, this, logLevel));
901        }
902
903        private void OnPropertyChanged(string name)
904        {
905            EventsHelper.PropertyChanged(PropertyChanged, this, new PropertyChangedEventArgs(name));
906        }
907
908        private void ProgressChanged(double value, double max)
909        {
910            EventsHelper.ProgressChanged(OnPluginProgressChanged, this, new PluginProgressEventArgs(value, max));
911        }
912
913        #endregion
914    }
915}
Note: See TracBrowser for help on using the repository browser.