Worked on Enigma, mainly changing how the notch positions are handled
[cipher-training.git] / enigma.ipynb
1 {
2 "cells": [
3 {
4 "cell_type": "markdown",
5 "metadata": {},
6 "source": [
7 "<a name=\"top\"></a>\n",
8 "# Enigma machine\n",
9 "\n",
10 "This is an implementation of an Enigma machine in Python. See below for links that describe the Enigma machine and how it was used.\n",
11 "\n",
12 "The Enigma machine has a bunch of components which can be swapped or modified to change its behaviour. The components are:\n",
13 "\n",
14 "* The plugboard\n",
15 "* The wheels (three chosen from a set of five)\n",
16 "* The reflector (two available, though generally not swapped)\n",
17 "\n",
18 "The plugboard and wheel selection were changed every day. The wheel orientation was changed every message.\n",
19 "\n",
20 "## Design sketch\n",
21 "Each of the components can be thought of as a \"letter transformer\", which take a letter and input and give a different letter as output. From a given setup (plugboard setting or wheel orientation), these transformations are deterministic: if nothing moves, the same letter input will give the same letter output. Depending on the component, forward and backward transformations can be different. For instance, the wheel I converts `a` to `e` forward, and `a` to `u` backward.\n",
22 "\n",
23 "This means we can take an object oriented approach to building the Enigma machine. The machine itself is a collection (aggregation) of components. Each component keeps track of its current state. \n",
24 "\n",
25 "The components have an inheritance hierarchy.\n",
26 "\n",
27 "* [LetterTransformer](#lettertransformer)\n",
28 " * [Plugobard](#plugboard)\n",
29 " * [Reflector](#reflector)\n",
30 " * [SimpleWheel](#simplewheel)\n",
31 " * [Wheel](#wheel)\n",
32 "\n",
33 "The `LetterTransformer` is the base class and defines the basic operations all the transformers apply. \n",
34 "\n",
35 "A `Plugboard` is a type of `LetterTransformer` that swaps only some letters, and acts the same both forward and backward. The `Reflector` acts like a `Plugboard` but with 13 pairs of swaps.\n",
36 "\n",
37 "A `SimpleWheel` has different forward and backward transforms, and also rotates. A `Wheel` is the same, but the indicator \"ring\" around the outside can be rotated around the core. This ring of a `Wheel` has a notch that can control when other `SimpleWheel`s and `Wheel`s are rotated in the Enigma.\n",
38 "\n",
39 "Note that all the logic of when the wheels rotate is controlled by the Enigma machine.\n",
40 "\n",
41 "* [Engima](#enigma)\n",
42 "* [Testing Enigma](#testingenigma)\n",
43 "\n",
44 "### Implmentation note\n",
45 "The normal way to define a class in Python is to define all the methods, class variables, and instance variables at the same time. However, that makes it difficult to place the discussion of the various methods and what they do near the definitions. \n",
46 "\n",
47 "This notebook takes a variant approach of defining the base class, then defining methods in separate cells and adding them to the class with the `setattr()` procedure.\n",
48 "\n",
49 "\n",
50 "## See also\n",
51 "* Specification from [Codes and Ciphers](http://www.codesandciphers.org.uk/enigma/rotorspec.htm) page.\n",
52 "\n",
53 "* Example Enigma machines from [Louise Dale](http://enigma.louisedade.co.uk/enigma.html) (full simulation) and [EnigmaCo](http://enigmaco.de/enigma/enigma.html) (good animation of the wheels, but no ring settings).\n",
54 "\n",
55 "* There's also the nice Enigma simulator for Android by [Franklin Heath](https://franklinheath.co.uk/2012/02/04/our-first-app-published-enigma-simulator/), available on the [Google Play store](https://play.google.com/store/apps/details?id=uk.co.franklinheath.enigmasim&hl=en_GB).\n",
56 "\n",
57 "* Enigma wiring from the [Crypto Museum](http://www.cryptomuseum.com/crypto/enigma/wiring.htm)."
58 ]
59 },
60 {
61 "cell_type": "markdown",
62 "metadata": {},
63 "source": [
64 "First, some general-purpose and utility imports. \n",
65 "\n",
66 "`pos` and `unpos` convert between letters and numbers (in range 0-25 inclusive)."
67 ]
68 },
69 {
70 "cell_type": "code",
71 "execution_count": 108,
72 "metadata": {
73 "collapsed": true
74 },
75 "outputs": [],
76 "source": [
77 "import string\n",
78 "import collections\n",
79 "\n",
80 "cat = ''.join\n",
81 "\n",
82 "def clean(text): return cat(l.lower() for l in text if l in string.ascii_letters)\n",
83 "\n",
84 "def pos(letter): \n",
85 " if letter in string.ascii_lowercase:\n",
86 " return ord(letter) - ord('a')\n",
87 " elif letter in string.ascii_uppercase:\n",
88 " return ord(letter) - ord('A')\n",
89 " else:\n",
90 " return ''\n",
91 " \n",
92 "def unpos(number): return chr(number % 26 + ord('a'))"
93 ]
94 },
95 {
96 "cell_type": "markdown",
97 "metadata": {},
98 "source": [
99 "The wheel specifications show what positions `a` to `z` (ignoring the ring) go to. For instance, Wheel 1 converts `a` to `e` forward, and `a` to `u` backward. The notch positions show where the wheel advance notches are on the wheel rings. The reflector specifications show the reflected pairs."
100 ]
101 },
102 {
103 "cell_type": "code",
104 "execution_count": 109,
105 "metadata": {
106 "collapsed": true
107 },
108 "outputs": [],
109 "source": [
110 "wheel_i_spec = 'ekmflgdqvzntowyhxuspaibrcj'\n",
111 "wheel_ii_spec = 'ajdksiruxblhwtmcqgznpyfvoe'\n",
112 "wheel_iii_spec = 'bdfhjlcprtxvznyeiwgakmusqo'\n",
113 "wheel_iv_spec = 'esovpzjayquirhxlnftgkdcmwb'\n",
114 "wheel_v_spec = 'vzbrgityupsdnhlxawmjqofeck'\n",
115 "wheel_vi_spec = 'jpgvoumfyqbenhzrdkasxlictw'\n",
116 "wheel_vii_spec = 'nzjhgrcxmyswboufaivlpekqdt'\n",
117 "wheel_viii_spec = 'fkqhtlxocbjspdzramewniuygv'\n",
118 "beta_wheel_spec = 'leyjvcnixwpbqmdrtakzgfuhos'\n",
119 "gamma_wheel_spec = 'fsokanuerhmbtiycwlqpzxvgjd'\n",
120 "\n",
121 "wheel_i_notches = ['q']\n",
122 "wheel_ii_notches = ['e']\n",
123 "wheel_iii_notches = ['v']\n",
124 "wheel_iv_notches = ['j']\n",
125 "wheel_v_notches = ['z']\n",
126 "wheel_vi_notches = ['z', 'm']\n",
127 "wheel_vii_notches = ['z', 'm']\n",
128 "wheel_viii_notches = ['z', 'm']\n",
129 "\n",
130 "reflector_b_spec = 'ay br cu dh eq fs gl ip jx kn mo tz vw'\n",
131 "reflector_c_spec = 'af bv cp dj ei go hy kr lz mx nw tq su'"
132 ]
133 },
134 {
135 "cell_type": "code",
136 "execution_count": 110,
137 "metadata": {
138 "collapsed": true
139 },
140 "outputs": [],
141 "source": [
142 "# class LetterTransformer(object):\n",
143 "# def __init__(self, specification, raw_transform=False):\n",
144 "# if raw_transform:\n",
145 "# transform = specification\n",
146 "# else:\n",
147 "# transform = self.parse_specification(specification)\n",
148 "# self.validate_transform(transform)\n",
149 "# self.make_transform_map(transform)\n",
150 " \n",
151 "# def parse_specification(self, specification):\n",
152 "# return list(zip(string.ascii_lowercase, clean(specification)))\n",
153 "# # return specification\n",
154 " \n",
155 "# def validate_transform(self, transform):\n",
156 "# \"\"\"A set of pairs, of from-to\"\"\"\n",
157 "# if len(transform) != 26:\n",
158 "# raise ValueError(\"Transform specification has {} pairs, requires 26\".\n",
159 "# format(len(transform)))\n",
160 "# for p in transform:\n",
161 "# if len(p) != 2:\n",
162 "# raise ValueError(\"Not all mappings in transform \"\n",
163 "# \"have two elements\")\n",
164 "# if len(set([p[0] for p in transform])) != 26:\n",
165 "# raise ValueError(\"Transform specification must list 26 origin letters\") \n",
166 "# if len(set([p[1] for p in transform])) != 26:\n",
167 "# raise ValueError(\"Transform specification must list 26 destination letters\") \n",
168 "\n",
169 "# def make_empty_transform(self):\n",
170 "# self.forward_map = [0] * 26\n",
171 "# self.backward_map = [0] * 26\n",
172 " \n",
173 "# def make_transform_map(self, transform):\n",
174 "# self.make_empty_transform()\n",
175 "# for p in transform:\n",
176 "# self.forward_map[pos(p[0])] = pos(p[1])\n",
177 "# self.backward_map[pos(p[1])] = pos(p[0])\n",
178 "# return self.forward_map, self.backward_map\n",
179 " \n",
180 "# def forward(self, letter):\n",
181 "# if letter in string.ascii_lowercase:\n",
182 "# return unpos(self.forward_map[pos(letter)])\n",
183 "# else:\n",
184 "# return ''\n",
185 " \n",
186 "# def backward(self, letter):\n",
187 "# if letter in string.ascii_lowercase:\n",
188 "# return unpos(self.backward_map[pos(letter)])\n",
189 "# else:\n",
190 "# return ''"
191 ]
192 },
193 {
194 "cell_type": "markdown",
195 "metadata": {},
196 "source": [
197 "<a name=\"lettertransformer\"></a>\n",
198 "# Letter transformer\n",
199 "[Top](#top)\n",
200 "\n",
201 "A generic transformer of letters. All components in the Enigma are based on this. \n",
202 "\n",
203 "The transformer has two directions, `forward` and `backward`. In each direction, a given letter is transformed into a different letter. Both transformations are general permutations of the alphabet (i.e. each letter goes to one and only one new letter). There is no general requirement for the `forward` and `backward` transformations to have any particular relationship to each other (even though most do in the Enigma machine).\n",
204 "\n",
205 "When created, it must be given the transformation which should be applied. A raw transform is a sequence of letter pairs, such that `p[0]` is transformed to `p[1]` forwards, and `p[1]` goes to `p[0]` backwards.\n",
206 "\n",
207 "If the transform is not raw, it's assumed that the specification is a sequence of the `p[1]`s, and the standard alphabet gives the `p[0]`s."
208 ]
209 },
210 {
211 "cell_type": "code",
212 "execution_count": 111,
213 "metadata": {
214 "collapsed": true
215 },
216 "outputs": [],
217 "source": [
218 "class LetterTransformer(object):\n",
219 " def __init__(self, specification, raw_transform=False):\n",
220 " if raw_transform:\n",
221 " transform = specification\n",
222 " else:\n",
223 " transform = self.parse_specification(specification)\n",
224 " self.validate_transform(transform)\n",
225 " self.make_transform_map(transform)"
226 ]
227 },
228 {
229 "cell_type": "markdown",
230 "metadata": {},
231 "source": [
232 "Parse a specification: convert a string of destination letters into a list of pairs. "
233 ]
234 },
235 {
236 "cell_type": "code",
237 "execution_count": 112,
238 "metadata": {
239 "collapsed": true
240 },
241 "outputs": [],
242 "source": [
243 "def parse_specification(self, specification):\n",
244 " return list(zip(string.ascii_lowercase, clean(specification)))\n",
245 " # return specification\n",
246 "\n",
247 "setattr(LetterTransformer, \"parse_specification\", parse_specification)"
248 ]
249 },
250 {
251 "cell_type": "code",
252 "execution_count": 113,
253 "metadata": {},
254 "outputs": [
255 {
256 "data": {
257 "text/plain": [
258 "[('a', 'e'),\n",
259 " ('b', 'k'),\n",
260 " ('c', 'm'),\n",
261 " ('d', 'f'),\n",
262 " ('e', 'l'),\n",
263 " ('f', 'g'),\n",
264 " ('g', 'd'),\n",
265 " ('h', 'q'),\n",
266 " ('i', 'v'),\n",
267 " ('j', 'z'),\n",
268 " ('k', 'n'),\n",
269 " ('l', 't'),\n",
270 " ('m', 'o'),\n",
271 " ('n', 'w'),\n",
272 " ('o', 'y'),\n",
273 " ('p', 'h'),\n",
274 " ('q', 'x'),\n",
275 " ('r', 'u'),\n",
276 " ('s', 's'),\n",
277 " ('t', 'p'),\n",
278 " ('u', 'a'),\n",
279 " ('v', 'i'),\n",
280 " ('w', 'b'),\n",
281 " ('x', 'r'),\n",
282 " ('y', 'c'),\n",
283 " ('z', 'j')]"
284 ]
285 },
286 "execution_count": 113,
287 "metadata": {},
288 "output_type": "execute_result"
289 }
290 ],
291 "source": [
292 "parse_specification(None, wheel_i_spec)"
293 ]
294 },
295 {
296 "cell_type": "markdown",
297 "metadata": {},
298 "source": [
299 "Checks that a transform is valid."
300 ]
301 },
302 {
303 "cell_type": "code",
304 "execution_count": 114,
305 "metadata": {
306 "collapsed": true
307 },
308 "outputs": [],
309 "source": [
310 "def validate_transform(self, transform):\n",
311 " \"\"\"A set of pairs, of from-to\"\"\"\n",
312 " if len(transform) != 26:\n",
313 " raise ValueError(\"Transform specification has {} pairs, requires 26\".\n",
314 " format(len(transform)))\n",
315 " for p in transform:\n",
316 " if len(p) != 2:\n",
317 " raise ValueError(\"Not all mappings in transform \"\n",
318 " \"have two elements\")\n",
319 " if len(set([p[0] for p in transform])) != 26:\n",
320 " raise ValueError(\"Transform specification must list 26 origin letters\") \n",
321 " if len(set([p[1] for p in transform])) != 26:\n",
322 " raise ValueError(\"Transform specification must list 26 destination letters\") \n",
323 "\n",
324 "setattr(LetterTransformer, \"validate_transform\", validate_transform) "
325 ]
326 },
327 {
328 "cell_type": "markdown",
329 "metadata": {},
330 "source": [
331 "The empty transform maps each letter to itself, forward and backward. A useful starting point for creating the maps needed.\n",
332 "\n",
333 "The forward and backward maps are `list`s of numbers (rather than `dict`s of letters to letters) to make the calculations easier when it comes to the wheels, and wheels with turnable indicator rings."
334 ]
335 },
336 {
337 "cell_type": "code",
338 "execution_count": 115,
339 "metadata": {
340 "collapsed": true
341 },
342 "outputs": [],
343 "source": [
344 "# def make_empty_transform(self):\n",
345 "# self.forward_map = [0] * 26\n",
346 "# self.backward_map = [0] * 26\n",
347 "\n",
348 "# setattr(LetterTransformer, \"make_empty_transform\", make_empty_transform) "
349 ]
350 },
351 {
352 "cell_type": "code",
353 "execution_count": 116,
354 "metadata": {
355 "collapsed": true
356 },
357 "outputs": [],
358 "source": [
359 "def make_empty_transform(self):\n",
360 " self.forward_map = list(range(26))\n",
361 " self.backward_map = list(range(26))\n",
362 "\n",
363 "setattr(LetterTransformer, \"make_empty_transform\", make_empty_transform) "
364 ]
365 },
366 {
367 "cell_type": "markdown",
368 "metadata": {},
369 "source": [
370 "Make the transform. Starting from an empty transform, mutate it to include the swaps. Note that the forward and backward swaps are stored separately. "
371 ]
372 },
373 {
374 "cell_type": "code",
375 "execution_count": 117,
376 "metadata": {
377 "collapsed": true
378 },
379 "outputs": [],
380 "source": [
381 "def make_transform_map(self, transform):\n",
382 " self.make_empty_transform()\n",
383 " for p in transform:\n",
384 " self.forward_map[pos(p[0])] = pos(p[1])\n",
385 " self.backward_map[pos(p[1])] = pos(p[0])\n",
386 " return self.forward_map, self.backward_map\n",
387 "\n",
388 "setattr(LetterTransformer, \"make_transform_map\", make_transform_map)"
389 ]
390 },
391 {
392 "cell_type": "code",
393 "execution_count": 118,
394 "metadata": {
395 "collapsed": true
396 },
397 "outputs": [],
398 "source": [
399 "def forward(self, letter):\n",
400 " if letter in string.ascii_lowercase:\n",
401 " return unpos(self.forward_map[pos(letter)])\n",
402 " else:\n",
403 " return ''\n",
404 "\n",
405 "def backward(self, letter):\n",
406 " if letter in string.ascii_lowercase:\n",
407 " return unpos(self.backward_map[pos(letter)])\n",
408 " else:\n",
409 " return ''\n",
410 "\n",
411 "setattr(LetterTransformer, \"forward\", forward)\n",
412 "setattr(LetterTransformer, \"backward\", backward) "
413 ]
414 },
415 {
416 "cell_type": "code",
417 "execution_count": 119,
418 "metadata": {},
419 "outputs": [
420 {
421 "data": {
422 "text/plain": [
423 "[('z', 'a'),\n",
424 " ('a', 'b'),\n",
425 " ('b', 'c'),\n",
426 " ('c', 'd'),\n",
427 " ('d', 'e'),\n",
428 " ('e', 'f'),\n",
429 " ('f', 'g'),\n",
430 " ('g', 'h'),\n",
431 " ('h', 'i'),\n",
432 " ('i', 'j'),\n",
433 " ('j', 'k'),\n",
434 " ('k', 'l'),\n",
435 " ('l', 'm'),\n",
436 " ('m', 'n'),\n",
437 " ('n', 'o'),\n",
438 " ('o', 'p'),\n",
439 " ('p', 'q'),\n",
440 " ('q', 'r'),\n",
441 " ('r', 's'),\n",
442 " ('s', 't'),\n",
443 " ('t', 'u'),\n",
444 " ('u', 'v'),\n",
445 " ('v', 'w'),\n",
446 " ('w', 'x'),\n",
447 " ('x', 'y'),\n",
448 " ('y', 'z')]"
449 ]
450 },
451 "execution_count": 119,
452 "metadata": {},
453 "output_type": "execute_result"
454 }
455 ],
456 "source": [
457 "tmap = [('z', 'a')] + [(l, string.ascii_lowercase[i+1]) for i, l in enumerate(string.ascii_lowercase[:-1])]\n",
458 "tmap"
459 ]
460 },
461 {
462 "cell_type": "code",
463 "execution_count": 120,
464 "metadata": {},
465 "outputs": [
466 {
467 "data": {
468 "text/plain": [
469 "'zyxwcabdefghijklmnopqrstuv'"
470 ]
471 },
472 "execution_count": 120,
473 "metadata": {},
474 "output_type": "execute_result"
475 }
476 ],
477 "source": [
478 "cat(collections.OrderedDict.fromkeys('zyxwc' + string.ascii_lowercase))"
479 ]
480 },
481 {
482 "cell_type": "code",
483 "execution_count": 121,
484 "metadata": {
485 "collapsed": true,
486 "scrolled": true
487 },
488 "outputs": [],
489 "source": [
490 "tmap2 = list(zip(string.ascii_lowercase, cat(collections.OrderedDict.fromkeys('zyxwc' + string.ascii_lowercase))))"
491 ]
492 },
493 {
494 "cell_type": "code",
495 "execution_count": 122,
496 "metadata": {
497 "scrolled": true
498 },
499 "outputs": [
500 {
501 "data": {
502 "text/plain": [
503 "([1,\n",
504 " 2,\n",
505 " 3,\n",
506 " 4,\n",
507 " 5,\n",
508 " 6,\n",
509 " 7,\n",
510 " 8,\n",
511 " 9,\n",
512 " 10,\n",
513 " 11,\n",
514 " 12,\n",
515 " 13,\n",
516 " 14,\n",
517 " 15,\n",
518 " 16,\n",
519 " 17,\n",
520 " 18,\n",
521 " 19,\n",
522 " 20,\n",
523 " 21,\n",
524 " 22,\n",
525 " 23,\n",
526 " 24,\n",
527 " 25,\n",
528 " 0],\n",
529 " [25,\n",
530 " 0,\n",
531 " 1,\n",
532 " 2,\n",
533 " 3,\n",
534 " 4,\n",
535 " 5,\n",
536 " 6,\n",
537 " 7,\n",
538 " 8,\n",
539 " 9,\n",
540 " 10,\n",
541 " 11,\n",
542 " 12,\n",
543 " 13,\n",
544 " 14,\n",
545 " 15,\n",
546 " 16,\n",
547 " 17,\n",
548 " 18,\n",
549 " 19,\n",
550 " 20,\n",
551 " 21,\n",
552 " 22,\n",
553 " 23,\n",
554 " 24])"
555 ]
556 },
557 "execution_count": 122,
558 "metadata": {},
559 "output_type": "execute_result"
560 }
561 ],
562 "source": [
563 "lt = LetterTransformer(tmap, raw_transform = True)\n",
564 "assert(lt.forward_map == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0])\n",
565 "assert(lt.backward_map == [25, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24])\n",
566 "lt.forward_map, lt.backward_map"
567 ]
568 },
569 {
570 "cell_type": "code",
571 "execution_count": 123,
572 "metadata": {
573 "scrolled": true
574 },
575 "outputs": [
576 {
577 "data": {
578 "text/plain": [
579 "([25,\n",
580 " 24,\n",
581 " 23,\n",
582 " 22,\n",
583 " 2,\n",
584 " 0,\n",
585 " 1,\n",
586 " 3,\n",
587 " 4,\n",
588 " 5,\n",
589 " 6,\n",
590 " 7,\n",
591 " 8,\n",
592 " 9,\n",
593 " 10,\n",
594 " 11,\n",
595 " 12,\n",
596 " 13,\n",
597 " 14,\n",
598 " 15,\n",
599 " 16,\n",
600 " 17,\n",
601 " 18,\n",
602 " 19,\n",
603 " 20,\n",
604 " 21],\n",
605 " [5,\n",
606 " 6,\n",
607 " 4,\n",
608 " 7,\n",
609 " 8,\n",
610 " 9,\n",
611 " 10,\n",
612 " 11,\n",
613 " 12,\n",
614 " 13,\n",
615 " 14,\n",
616 " 15,\n",
617 " 16,\n",
618 " 17,\n",
619 " 18,\n",
620 " 19,\n",
621 " 20,\n",
622 " 21,\n",
623 " 22,\n",
624 " 23,\n",
625 " 24,\n",
626 " 25,\n",
627 " 3,\n",
628 " 2,\n",
629 " 1,\n",
630 " 0])"
631 ]
632 },
633 "execution_count": 123,
634 "metadata": {},
635 "output_type": "execute_result"
636 }
637 ],
638 "source": [
639 "lt = LetterTransformer(cat(collections.OrderedDict.fromkeys('zyxwc' + string.ascii_lowercase)))\n",
640 "assert(lt.forward_map == [25, 24, 23, 22, 2, 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21])\n",
641 "assert(lt.backward_map == [5, 6, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 3, 2, 1, 0])\n",
642 "assert(cat(lt.forward(l) for l in string.ascii_lowercase) == 'zyxwcabdefghijklmnopqrstuv')\n",
643 "assert(cat(lt.backward(l) for l in string.ascii_lowercase) == 'fgehijklmnopqrstuvwxyzdcba')\n",
644 "lt.forward_map, lt.backward_map"
645 ]
646 },
647 {
648 "cell_type": "code",
649 "execution_count": 124,
650 "metadata": {},
651 "outputs": [
652 {
653 "data": {
654 "text/plain": [
655 "'zyxwcabdefghijklmnopqrstuv'"
656 ]
657 },
658 "execution_count": 124,
659 "metadata": {},
660 "output_type": "execute_result"
661 }
662 ],
663 "source": [
664 "cat(lt.forward(l) for l in string.ascii_lowercase)"
665 ]
666 },
667 {
668 "cell_type": "code",
669 "execution_count": 125,
670 "metadata": {},
671 "outputs": [
672 {
673 "data": {
674 "text/plain": [
675 "'fgehijklmnopqrstuvwxyzdcba'"
676 ]
677 },
678 "execution_count": 125,
679 "metadata": {},
680 "output_type": "execute_result"
681 }
682 ],
683 "source": [
684 "cat(lt.backward(l) for l in string.ascii_lowercase)"
685 ]
686 },
687 {
688 "cell_type": "markdown",
689 "metadata": {},
690 "source": [
691 "<a name=\"plugboard\"></a>\n",
692 "## Plugboard\n",
693 "[Top](#top)\n",
694 "\n",
695 "A `Plugboard` is a `LetterTransformer` that swaps some pairs of letters, and does the same swaps forward and backward."
696 ]
697 },
698 {
699 "cell_type": "code",
700 "execution_count": 126,
701 "metadata": {
702 "collapsed": true
703 },
704 "outputs": [],
705 "source": [
706 "class Plugboard(LetterTransformer):\n",
707 " def parse_specification(self, specification):\n",
708 " return [tuple(clean(p)) for p in specification.split()]\n",
709 " \n",
710 " def validate_transform(self, transform):\n",
711 " \"\"\"A set of pairs, of from-to\"\"\"\n",
712 " for p in transform:\n",
713 " if len(p) != 2:\n",
714 " raise ValueError(\"Not all mappings in transform\"\n",
715 " \"have two elements\")\n",
716 " \n",
717 "# def make_empty_transform(self):\n",
718 "# self.forward_map = list(range(26))\n",
719 "# self.backward_map = list(range(26))\n",
720 " \n",
721 " def make_transform_map(self, transform):\n",
722 " expanded_transform = transform + [tuple(reversed(p)) for p in transform]\n",
723 " return super(Plugboard, self).make_transform_map(expanded_transform)"
724 ]
725 },
726 {
727 "cell_type": "code",
728 "execution_count": 127,
729 "metadata": {
730 "collapsed": true
731 },
732 "outputs": [],
733 "source": [
734 "pb = Plugboard([('a', 'z'), ('b', 'y')], raw_transform=True)"
735 ]
736 },
737 {
738 "cell_type": "code",
739 "execution_count": 128,
740 "metadata": {},
741 "outputs": [
742 {
743 "data": {
744 "text/plain": [
745 "'zycdefghijklmnopqrstuvwxba'"
746 ]
747 },
748 "execution_count": 128,
749 "metadata": {},
750 "output_type": "execute_result"
751 }
752 ],
753 "source": [
754 "cat(pb.forward(l) for l in string.ascii_lowercase)"
755 ]
756 },
757 {
758 "cell_type": "code",
759 "execution_count": 129,
760 "metadata": {},
761 "outputs": [
762 {
763 "data": {
764 "text/plain": [
765 "'zycdefghijklmnopqrstuvwxba'"
766 ]
767 },
768 "execution_count": 129,
769 "metadata": {},
770 "output_type": "execute_result"
771 }
772 ],
773 "source": [
774 "cat(pb.backward(l) for l in string.ascii_lowercase)"
775 ]
776 },
777 {
778 "cell_type": "code",
779 "execution_count": 130,
780 "metadata": {
781 "collapsed": true
782 },
783 "outputs": [],
784 "source": [
785 "pb = Plugboard('az by')"
786 ]
787 },
788 {
789 "cell_type": "code",
790 "execution_count": 131,
791 "metadata": {},
792 "outputs": [
793 {
794 "data": {
795 "text/plain": [
796 "('zycdefghijklmnopqrstuvwxba', 'zycdefghijklmnopqrstuvwxba')"
797 ]
798 },
799 "execution_count": 131,
800 "metadata": {},
801 "output_type": "execute_result"
802 }
803 ],
804 "source": [
805 "cat(pb.forward(l) for l in string.ascii_lowercase), cat(pb.backward(l) for l in string.ascii_lowercase)"
806 ]
807 },
808 {
809 "cell_type": "code",
810 "execution_count": 132,
811 "metadata": {},
812 "outputs": [
813 {
814 "data": {
815 "text/plain": [
816 "('ugcdypblnzkhmisfrqoxavwtej', 'ugcdypblnzkhmisfrqoxavwtej')"
817 ]
818 },
819 "execution_count": 132,
820 "metadata": {},
821 "output_type": "execute_result"
822 }
823 ],
824 "source": [
825 "pb = Plugboard('ua pf rq so ni ey bg hl tx zj'.upper())\n",
826 "assert(pb.forward_map == pb.backward_map)\n",
827 "assert(pb.forward_map == [20, 6, 2, 3, 24, 15, 1, 11, 13, 25, 10, 7, 12, 8, 18, 5, 17, 16, 14, 23, 0, 21, 22, 19, 4, 9])\n",
828 "assert(cat(pb.forward(l) for l in string.ascii_lowercase) == 'ugcdypblnzkhmisfrqoxavwtej')\n",
829 "assert(cat(pb.backward(l) for l in string.ascii_lowercase) == 'ugcdypblnzkhmisfrqoxavwtej')\n",
830 "cat(pb.forward(l) for l in string.ascii_lowercase), cat(pb.backward(l) for l in string.ascii_lowercase)"
831 ]
832 },
833 {
834 "cell_type": "markdown",
835 "metadata": {},
836 "source": [
837 "<a name=\"reflector\"></a>\n",
838 "## Reflector\n",
839 "[Top](#top)\n",
840 "\n",
841 "A `Reflector` is a `Plugboard` that takes exactly 13 pairs of letters to swap."
842 ]
843 },
844 {
845 "cell_type": "code",
846 "execution_count": 133,
847 "metadata": {
848 "collapsed": true
849 },
850 "outputs": [],
851 "source": [
852 "class Reflector(Plugboard):\n",
853 " def validate_transform(self, transform):\n",
854 " if len(transform) != 13:\n",
855 " raise ValueError(\"Reflector specification has {} pairs, requires 13\".\n",
856 " format(len(transform)))\n",
857 " if len(set([p[0] for p in transform] + \n",
858 " [p[1] for p in transform])) != 26:\n",
859 " raise ValueError(\"Reflector specification does not contain 26 letters\")\n",
860 " try:\n",
861 " super(Reflector, self).validate_transform(transform)\n",
862 " except ValueError as v:\n",
863 " raise ValueError(\"Not all mappings in reflector have two elements\")"
864 ]
865 },
866 {
867 "cell_type": "code",
868 "execution_count": 134,
869 "metadata": {},
870 "outputs": [
871 {
872 "data": {
873 "text/plain": [
874 "[('a', 'y'),\n",
875 " ('b', 'r'),\n",
876 " ('c', 'u'),\n",
877 " ('d', 'h'),\n",
878 " ('e', 'q'),\n",
879 " ('f', 's'),\n",
880 " ('g', 'l'),\n",
881 " ('i', 'p'),\n",
882 " ('j', 'x'),\n",
883 " ('k', 'n'),\n",
884 " ('m', 'o'),\n",
885 " ('t', 'z'),\n",
886 " ('v', 'w')]"
887 ]
888 },
889 "execution_count": 134,
890 "metadata": {},
891 "output_type": "execute_result"
892 }
893 ],
894 "source": [
895 "# reflector_b_text = '(AY) (BR) (CU) (DH) (EQ) (FS) (GL) (IP) (JX) (KN) (MO) (TZ) (VW)'\n",
896 "reflector_b_l = [tuple(clean(p)) for p in reflector_b_spec.split()]\n",
897 "reflector_b_l"
898 ]
899 },
900 {
901 "cell_type": "code",
902 "execution_count": 135,
903 "metadata": {
904 "collapsed": true
905 },
906 "outputs": [],
907 "source": [
908 "reflector_b = Reflector(reflector_b_spec)\n",
909 "assert(reflector_b.forward_map == reflector_b.backward_map)\n",
910 "assert(reflector_b.forward_map == [24, 17, 20, 7, 16, 18, 11, 3, 15, 23, 13, 6, 14, 10, 12, 8, 4, 1, 5, 25, 2, 22, 21, 9, 0, 19])\n",
911 "assert(cat(reflector_b.forward(l) for l in string.ascii_lowercase) == 'yruhqsldpxngokmiebfzcwvjat')\n",
912 "assert(cat(reflector_b.backward(l) for l in string.ascii_lowercase) == 'yruhqsldpxngokmiebfzcwvjat')"
913 ]
914 },
915 {
916 "cell_type": "code",
917 "execution_count": 136,
918 "metadata": {},
919 "outputs": [
920 {
921 "data": {
922 "text/plain": [
923 "'yruhqsldpxngokmiebfzcwvjat'"
924 ]
925 },
926 "execution_count": 136,
927 "metadata": {},
928 "output_type": "execute_result"
929 }
930 ],
931 "source": [
932 "cat(reflector_b.forward(l) for l in string.ascii_lowercase)"
933 ]
934 },
935 {
936 "cell_type": "code",
937 "execution_count": 137,
938 "metadata": {
939 "collapsed": true
940 },
941 "outputs": [],
942 "source": [
943 "reflector_c = Reflector(reflector_c_spec)"
944 ]
945 },
946 {
947 "cell_type": "code",
948 "execution_count": 138,
949 "metadata": {},
950 "outputs": [
951 {
952 "data": {
953 "text/plain": [
954 "'fvpjiaoyedrzxwgctkuqsbnmhl'"
955 ]
956 },
957 "execution_count": 138,
958 "metadata": {},
959 "output_type": "execute_result"
960 }
961 ],
962 "source": [
963 "cat(reflector_c.forward(l) for l in string.ascii_lowercase)"
964 ]
965 },
966 {
967 "cell_type": "markdown",
968 "metadata": {},
969 "source": [
970 "<a name=\"simplewheel\"></a>\n",
971 "## SimpleWheel\n",
972 "[Top](#top)\n",
973 "\n",
974 "A `SimpleWheel` has different forward and backward maps, and also a position. The position is set with the `set_position` method (and initially in the creator), and the wheel can advance using the `advance` method. \n",
975 "\n",
976 "How the position is used is best explained with an example. The Enigma wheel 1, in the neutral position, transforms `a` to `e` (+4 letters) and `b` to `k` (+10 letters). When the wheel is in position `b` and an `a` in enciphered, it's the _second_ element of the map that's used, so `a` would be advanced 10 letters, to give `j`.\n",
977 "\n",
978 "This means that when using the letter transformation maps, you use the element in the map that's offset by the position of the wheel. When enciphering a `c`, you'd normally use transformation at position 2 in the map; if the wheel is in position 7, you'd instead use the transform at position 2 + 7 = 9 in the map.\n",
979 "\n",
980 "There are various modulus operators to keep the numbers in the requried range, meaning you can wrap around the map and around the wheel.\n",
981 "\n",
982 "Note the use of `__getattribute__` to give a more human-friendly version of the position without making it a method call. That allows you to write `wheel.position` and `wheel.position_l` and get the appropriate answers."
983 ]
984 },
985 {
986 "cell_type": "code",
987 "execution_count": 139,
988 "metadata": {
989 "collapsed": true
990 },
991 "outputs": [],
992 "source": [
993 "class SimpleWheel(LetterTransformer):\n",
994 " def __init__(self, transform, position='a', raw_transform=False):\n",
995 " super(SimpleWheel, self).__init__(transform, raw_transform)\n",
996 " self.set_position(position)\n",
997 " \n",
998 " def __getattribute__(self, name):\n",
999 " if name=='position_l':\n",
1000 " return unpos(self.position)\n",
1001 " else:\n",
1002 " return object.__getattribute__(self, name) "
1003 ]
1004 },
1005 {
1006 "cell_type": "markdown",
1007 "metadata": {},
1008 "source": [
1009 "Set the wheel to a new position. Note that it expects a letter, not a number."
1010 ]
1011 },
1012 {
1013 "cell_type": "code",
1014 "execution_count": 140,
1015 "metadata": {
1016 "collapsed": true
1017 },
1018 "outputs": [],
1019 "source": [
1020 "def set_position(self, position):\n",
1021 " self.position = ord(position) - ord('a')\n",
1022 " \n",
1023 "setattr(SimpleWheel, 'set_position', set_position) "
1024 ]
1025 },
1026 {
1027 "cell_type": "markdown",
1028 "metadata": {},
1029 "source": [
1030 "Advance the wheel one step. Note that advancing beyond position 25 moves back to 0."
1031 ]
1032 },
1033 {
1034 "cell_type": "code",
1035 "execution_count": 141,
1036 "metadata": {
1037 "collapsed": true
1038 },
1039 "outputs": [],
1040 "source": [
1041 "def advance(self):\n",
1042 " self.position = (self.position + 1) % 26\n",
1043 " return self.position\n",
1044 "\n",
1045 "setattr(SimpleWheel, 'advance', advance) "
1046 ]
1047 },
1048 {
1049 "cell_type": "markdown",
1050 "metadata": {},
1051 "source": [
1052 "Do the encipherment forward and backward. Note how the map element to use is affected by the wheel position, and how the modulus wraps that map element around the wheel if needed."
1053 ]
1054 },
1055 {
1056 "cell_type": "code",
1057 "execution_count": 142,
1058 "metadata": {
1059 "collapsed": true
1060 },
1061 "outputs": [],
1062 "source": [
1063 "def forward(self, letter):\n",
1064 " if letter in string.ascii_lowercase:\n",
1065 " return unpos((self.forward_map[(pos(letter) + self.position) % 26] - self.position))\n",
1066 " else:\n",
1067 " return ''\n",
1068 "\n",
1069 "def backward(self, letter):\n",
1070 " if letter in string.ascii_lowercase:\n",
1071 " return unpos((self.backward_map[(pos(letter) + self.position) % 26] - self.position))\n",
1072 " else:\n",
1073 " return ''\n",
1074 " \n",
1075 "setattr(SimpleWheel, 'forward', forward) \n",
1076 "setattr(SimpleWheel, 'backward', backward) "
1077 ]
1078 },
1079 {
1080 "cell_type": "code",
1081 "execution_count": 143,
1082 "metadata": {
1083 "scrolled": true
1084 },
1085 "outputs": [
1086 {
1087 "data": {
1088 "text/plain": [
1089 "[('a', 'e'),\n",
1090 " ('b', 'k'),\n",
1091 " ('c', 'm'),\n",
1092 " ('d', 'f'),\n",
1093 " ('e', 'l'),\n",
1094 " ('f', 'g'),\n",
1095 " ('g', 'd'),\n",
1096 " ('h', 'q'),\n",
1097 " ('i', 'v'),\n",
1098 " ('j', 'z'),\n",
1099 " ('k', 'n'),\n",
1100 " ('l', 't'),\n",
1101 " ('m', 'o'),\n",
1102 " ('n', 'w'),\n",
1103 " ('o', 'y'),\n",
1104 " ('p', 'h'),\n",
1105 " ('q', 'x'),\n",
1106 " ('r', 'u'),\n",
1107 " ('s', 's'),\n",
1108 " ('t', 'p'),\n",
1109 " ('u', 'a'),\n",
1110 " ('v', 'i'),\n",
1111 " ('w', 'b'),\n",
1112 " ('x', 'r'),\n",
1113 " ('y', 'c'),\n",
1114 " ('z', 'j')]"
1115 ]
1116 },
1117 "execution_count": 143,
1118 "metadata": {},
1119 "output_type": "execute_result"
1120 }
1121 ],
1122 "source": [
1123 "rotor_1_transform = list(zip(string.ascii_lowercase, 'EKMFLGDQVZNTOWYHXUSPAIBRCJ'.lower()))\n",
1124 "rotor_1_transform"
1125 ]
1126 },
1127 {
1128 "cell_type": "code",
1129 "execution_count": 144,
1130 "metadata": {
1131 "collapsed": true
1132 },
1133 "outputs": [],
1134 "source": [
1135 "rotor_1_transform = list(zip(string.ascii_lowercase, 'EKMFLGDQVZNTOWYHXUSPAIBRCJ'.lower()))\n",
1136 "wheel_1 = SimpleWheel(rotor_1_transform, raw_transform=True)\n",
1137 "assert(cat(wheel_1.forward(l) for l in string.ascii_lowercase) == 'ekmflgdqvzntowyhxuspaibrcj')\n",
1138 "assert(cat(wheel_1.backward(l) for l in string.ascii_lowercase) == 'uwygadfpvzbeckmthxslrinqoj')"
1139 ]
1140 },
1141 {
1142 "cell_type": "code",
1143 "execution_count": 145,
1144 "metadata": {
1145 "scrolled": true
1146 },
1147 "outputs": [
1148 {
1149 "data": {
1150 "text/plain": [
1151 "[4,\n",
1152 " 10,\n",
1153 " 12,\n",
1154 " 5,\n",
1155 " 11,\n",
1156 " 6,\n",
1157 " 3,\n",
1158 " 16,\n",
1159 " 21,\n",
1160 " 25,\n",
1161 " 13,\n",
1162 " 19,\n",
1163 " 14,\n",
1164 " 22,\n",
1165 " 24,\n",
1166 " 7,\n",
1167 " 23,\n",
1168 " 20,\n",
1169 " 18,\n",
1170 " 15,\n",
1171 " 0,\n",
1172 " 8,\n",
1173 " 1,\n",
1174 " 17,\n",
1175 " 2,\n",
1176 " 9]"
1177 ]
1178 },
1179 "execution_count": 145,
1180 "metadata": {},
1181 "output_type": "execute_result"
1182 }
1183 ],
1184 "source": [
1185 "wheel_1.forward_map"
1186 ]
1187 },
1188 {
1189 "cell_type": "code",
1190 "execution_count": 146,
1191 "metadata": {},
1192 "outputs": [
1193 {
1194 "data": {
1195 "text/plain": [
1196 "'j'"
1197 ]
1198 },
1199 "execution_count": 146,
1200 "metadata": {},
1201 "output_type": "execute_result"
1202 }
1203 ],
1204 "source": [
1205 "wheel_1.advance()\n",
1206 "wheel_1.forward('a')"
1207 ]
1208 },
1209 {
1210 "cell_type": "code",
1211 "execution_count": 147,
1212 "metadata": {},
1213 "outputs": [
1214 {
1215 "data": {
1216 "text/plain": [
1217 "('jlekfcpuymsnvxgwtrozhaqbid', 'vxfzceouyadbjlsgwrkqhmpnit')"
1218 ]
1219 },
1220 "execution_count": 147,
1221 "metadata": {},
1222 "output_type": "execute_result"
1223 }
1224 ],
1225 "source": [
1226 "cat(wheel_1.forward(l) for l in string.ascii_lowercase), cat(wheel_1.backward(l) for l in string.ascii_lowercase)"
1227 ]
1228 },
1229 {
1230 "cell_type": "code",
1231 "execution_count": 148,
1232 "metadata": {},
1233 "outputs": [
1234 {
1235 "data": {
1236 "text/plain": [
1237 "'b'"
1238 ]
1239 },
1240 "execution_count": 148,
1241 "metadata": {},
1242 "output_type": "execute_result"
1243 }
1244 ],
1245 "source": [
1246 "wheel_1.position_l"
1247 ]
1248 },
1249 {
1250 "cell_type": "code",
1251 "execution_count": 149,
1252 "metadata": {
1253 "collapsed": true
1254 },
1255 "outputs": [],
1256 "source": [
1257 "wheel_2 = SimpleWheel(wheel_ii_spec)\n",
1258 "assert(cat(wheel_2.forward(l) for l in string.ascii_lowercase) == 'ajdksiruxblhwtmcqgznpyfvoe')\n",
1259 "assert(cat(wheel_2.backward(l) for l in string.ascii_lowercase) == 'ajpczwrlfbdkotyuqgenhxmivs')"
1260 ]
1261 },
1262 {
1263 "cell_type": "code",
1264 "execution_count": 150,
1265 "metadata": {},
1266 "outputs": [
1267 {
1268 "data": {
1269 "text/plain": [
1270 "('ajdksiruxblhwtmcqgznpyfvoe', 'ajpczwrlfbdkotyuqgenhxmivs')"
1271 ]
1272 },
1273 "execution_count": 150,
1274 "metadata": {},
1275 "output_type": "execute_result"
1276 }
1277 ],
1278 "source": [
1279 "cat(wheel_2.forward(l) for l in string.ascii_lowercase), cat(wheel_2.backward(l) for l in string.ascii_lowercase)"
1280 ]
1281 },
1282 {
1283 "cell_type": "code",
1284 "execution_count": 151,
1285 "metadata": {},
1286 "outputs": [
1287 {
1288 "data": {
1289 "text/plain": [
1290 "('bdfhjlcprtxvznyeiwgakmusqo', 'tagbpcsdqeufvnzhyixjwlrkom')"
1291 ]
1292 },
1293 "execution_count": 151,
1294 "metadata": {},
1295 "output_type": "execute_result"
1296 }
1297 ],
1298 "source": [
1299 "wheel_3 = SimpleWheel(wheel_iii_spec)\n",
1300 "wheel_3.set_position('a')\n",
1301 "wheel_3.advance()\n",
1302 "assert(cat(wheel_3.forward(l) for l in string.ascii_lowercase) == 'cegikboqswuymxdhvfzjltrpna')\n",
1303 "assert(cat(wheel_3.backward(l) for l in string.ascii_lowercase) == 'zfaobrcpdteumygxhwivkqjnls')\n",
1304 "assert(wheel_3.position == 1)\n",
1305 "assert(wheel_3.position_l == 'b')\n",
1306 "\n",
1307 "for _ in range(24): wheel_3.advance()\n",
1308 "assert(wheel_3.position == 25)\n",
1309 "assert(wheel_3.position_l == 'z')\n",
1310 "assert(cat(wheel_3.forward(l) for l in string.ascii_lowercase) == 'pcegikmdqsuywaozfjxhblnvtr')\n",
1311 "assert(cat(wheel_3.backward(l) for l in string.ascii_lowercase) == 'nubhcqdterfvgwoaizjykxmslp')\n",
1312 "\n",
1313 "wheel_3.advance()\n",
1314 "assert(wheel_3.position == 0)\n",
1315 "assert(wheel_3.position_l == 'a')\n",
1316 "assert(cat(wheel_3.forward(l) for l in string.ascii_lowercase) == 'bdfhjlcprtxvznyeiwgakmusqo')\n",
1317 "assert(cat(wheel_3.backward(l) for l in string.ascii_lowercase) == 'tagbpcsdqeufvnzhyixjwlrkom')\n",
1318 "\n",
1319 "cat(wheel_3.forward(l) for l in string.ascii_lowercase), cat(wheel_3.backward(l) for l in string.ascii_lowercase)"
1320 ]
1321 },
1322 {
1323 "cell_type": "markdown",
1324 "metadata": {},
1325 "source": [
1326 "<a name=\"wheel\"></a>\n",
1327 "## Wheel\n",
1328 "[Top](#top)\n",
1329 "\n",
1330 "This is the same as a `SimpleWheel`, but with the addition of a ring.\n",
1331 "\n",
1332 "The ring is moveable around the core of the wheel (with the wiring). This means that moving the ring changes the orientation of the core and wiring for the same setting.\n",
1333 "\n",
1334 "| Wheel with notch | Notch showing peg to hold it in place |\n",
1335 "| ---------------- | ------------------------------------- |\n",
1336 "| <img src=\"enigma-notch.jpg\" alt=\"Enigma wheel with notch\" width=300> | <img src=\"dtu_notch_big.jpg\" alt=\"Enigma wheel with notch\" width=300> |\n",
1337 "| (From [Crypto museum](http://www.cryptomuseum.com/crypto/enigma/img/300879/035/full.jpg)) | From [Matematik Sider](http://www.matematiksider.dk/enigma/dtu_notch_big.jpg) |\n",
1338 "\n",
1339 "Though it's not very visible in the right hand image, the extra metal below the ring shows a spring-loaded peg on the wheel core which drops into the ring, with one hole per letter. The ring setting is where the peg drops into the ring.\n",
1340 "\n",
1341 "The notch setting is used in the full Enigma to control when the wheels step forward.\n",
1342 "\n",
1343 "Note that the constructor calls the superclass's constructor, then sets the positions properly with a call to `set_position`."
1344 ]
1345 },
1346 {
1347 "cell_type": "code",
1348 "execution_count": 152,
1349 "metadata": {
1350 "collapsed": true
1351 },
1352 "outputs": [],
1353 "source": [
1354 "class Wheel(SimpleWheel):\n",
1355 " def __init__(self, transform, ring_notch_letters, ring_setting=1, position='a', raw_transform=False):\n",
1356 " self.ring_notch_letters = ring_notch_letters\n",
1357 " self.ring_setting = ring_setting\n",
1358 " super(Wheel, self).__init__(transform, position=position, raw_transform=raw_transform)\n",
1359 " self.set_position(position)"
1360 ]
1361 },
1362 {
1363 "cell_type": "markdown",
1364 "metadata": {},
1365 "source": [
1366 "The `position` of the wheel is the orientation of the core. It's the same as the ring if the ring setting is 1. The `position_l` attribute is used to report the position of the ring letter, which is what the Enigma operator would see. "
1367 ]
1368 },
1369 {
1370 "cell_type": "code",
1371 "execution_count": 153,
1372 "metadata": {},
1373 "outputs": [],
1374 "source": [
1375 "def __getattribute__(self,name):\n",
1376 " if name=='position_l':\n",
1377 " return unpos(self.position + self.ring_setting - 1)\n",
1378 " else:\n",
1379 " return object.__getattribute__(self, name)\n",
1380 "\n",
1381 "def set_position(self, position):\n",
1382 "# self.position = (pos(position) - self.ring_setting + 1) % 26\n",
1383 " if isinstance(position, str):\n",
1384 " self.position = (pos(position) - self.ring_setting + 1) % 26\n",
1385 " else:\n",
1386 " self.position = (position - self.ring_setting) % 26\n",
1387 "# self.notch_positions = [(pos(position) - pos(p)) % 26 for p in self.ring_notch_letters]\n",
1388 " self.notch_positions = [(self.position + self.ring_setting - 1 - pos(p)) % 26 for p in self.ring_notch_letters]\n",
1389 " \n",
1390 "setattr(Wheel, '__getattribute__', __getattribute__) \n",
1391 "setattr(Wheel, 'set_position', set_position) "
1392 ]
1393 },
1394 {
1395 "cell_type": "markdown",
1396 "metadata": {},
1397 "source": [
1398 "Advance the wheel. Again, note the superclass call, followed by the update of the notch positions."
1399 ]
1400 },
1401 {
1402 "cell_type": "code",
1403 "execution_count": 154,
1404 "metadata": {
1405 "collapsed": true
1406 },
1407 "outputs": [],
1408 "source": [
1409 "def advance(self):\n",
1410 " super(Wheel, self).advance()\n",
1411 " self.notch_positions = [(p + 1) % 26 for p in self.notch_positions]\n",
1412 " # self.position_l = unpos(self.position + self.ring_setting - 1)\n",
1413 " return self.position\n",
1414 " \n",
1415 "setattr(Wheel, 'advance', advance) "
1416 ]
1417 },
1418 {
1419 "cell_type": "code",
1420 "execution_count": 155,
1421 "metadata": {
1422 "collapsed": true
1423 },
1424 "outputs": [],
1425 "source": [
1426 "wheel_3 = Wheel(wheel_iii_spec, wheel_iii_notches, position='b', ring_setting=1)"
1427 ]
1428 },
1429 {
1430 "cell_type": "code",
1431 "execution_count": 156,
1432 "metadata": {},
1433 "outputs": [
1434 {
1435 "data": {
1436 "text/plain": [
1437 "(1, [6])"
1438 ]
1439 },
1440 "execution_count": 156,
1441 "metadata": {},
1442 "output_type": "execute_result"
1443 }
1444 ],
1445 "source": [
1446 "wheel_3.position, wheel_3.notch_positions"
1447 ]
1448 },
1449 {
1450 "cell_type": "code",
1451 "execution_count": 157,
1452 "metadata": {},
1453 "outputs": [
1454 {
1455 "data": {
1456 "text/plain": [
1457 "(25, [2, 15])"
1458 ]
1459 },
1460 "execution_count": 157,
1461 "metadata": {},
1462 "output_type": "execute_result"
1463 }
1464 ],
1465 "source": [
1466 "wheel_6 = Wheel(wheel_vi_spec, wheel_vi_notches, position='b', ring_setting=3)\n",
1467 "wheel_6.position, wheel_6.notch_positions"
1468 ]
1469 },
1470 {
1471 "cell_type": "code",
1472 "execution_count": 158,
1473 "metadata": {
1474 "scrolled": true
1475 },
1476 "outputs": [
1477 {
1478 "name": "stdout",
1479 "output_type": "stream",
1480 "text": [
1481 "0 [3, 16]\n",
1482 "1 [4, 17]\n",
1483 "2 [5, 18]\n",
1484 "3 [6, 19]\n",
1485 "4 [7, 20]\n",
1486 "5 [8, 21]\n",
1487 "6 [9, 22]\n",
1488 "7 [10, 23]\n",
1489 "8 [11, 24]\n",
1490 "9 [12, 25]\n",
1491 "10 [13, 0]\n",
1492 "11 [14, 1]\n",
1493 "12 [15, 2]\n",
1494 "13 [16, 3]\n",
1495 "14 [17, 4]\n",
1496 "15 [18, 5]\n",
1497 "16 [19, 6]\n",
1498 "17 [20, 7]\n",
1499 "18 [21, 8]\n",
1500 "19 [22, 9]\n",
1501 "20 [23, 10]\n",
1502 "21 [24, 11]\n",
1503 "22 [25, 12]\n",
1504 "23 [0, 13]\n",
1505 "24 [1, 14]\n",
1506 "25 [2, 15]\n",
1507 "0 [3, 16]\n"
1508 ]
1509 }
1510 ],
1511 "source": [
1512 "for _ in range(27):\n",
1513 " wheel_6.advance()\n",
1514 " print(wheel_6.position, wheel_6.notch_positions)"
1515 ]
1516 },
1517 {
1518 "cell_type": "code",
1519 "execution_count": 159,
1520 "metadata": {},
1521 "outputs": [],
1522 "source": [
1523 "wheel = Wheel(wheel_iii_spec, wheel_iii_notches, position='b', \n",
1524 " ring_setting=3)\n",
1525 "wheel.set_position(12)\n",
1526 "assert(wheel.position == 9)\n",
1527 "assert(16 in wheel.notch_positions)\n",
1528 "assert(wheel.position_l =='l')"
1529 ]
1530 },
1531 {
1532 "cell_type": "code",
1533 "execution_count": 160,
1534 "metadata": {},
1535 "outputs": [
1536 {
1537 "data": {
1538 "text/plain": [
1539 "[16]"
1540 ]
1541 },
1542 "execution_count": 160,
1543 "metadata": {},
1544 "output_type": "execute_result"
1545 }
1546 ],
1547 "source": [
1548 "wheel.notch_positions"
1549 ]
1550 },
1551 {
1552 "cell_type": "code",
1553 "execution_count": 161,
1554 "metadata": {},
1555 "outputs": [
1556 {
1557 "data": {
1558 "text/plain": [
1559 "'l'"
1560 ]
1561 },
1562 "execution_count": 161,
1563 "metadata": {},
1564 "output_type": "execute_result"
1565 }
1566 ],
1567 "source": [
1568 "wheel.position_l"
1569 ]
1570 },
1571 {
1572 "cell_type": "code",
1573 "execution_count": 162,
1574 "metadata": {
1575 "collapsed": true
1576 },
1577 "outputs": [],
1578 "source": [
1579 "wheel_3 = Wheel(wheel_iii_spec, wheel_iii_notches, position='b', ring_setting=1)\n",
1580 "assert(wheel_3.position == 1)\n",
1581 "assert(wheel_3.notch_positions == [6])\n",
1582 "assert(wheel_3.position_l == 'b')\n",
1583 "wheel_3.advance()\n",
1584 "assert(wheel_3.position == 2)\n",
1585 "assert(wheel_3.notch_positions == [7])\n",
1586 "assert(wheel_3.position_l == 'c')"
1587 ]
1588 },
1589 {
1590 "cell_type": "code",
1591 "execution_count": 163,
1592 "metadata": {},
1593 "outputs": [
1594 {
1595 "data": {
1596 "text/plain": [
1597 "[2, 15]"
1598 ]
1599 },
1600 "execution_count": 163,
1601 "metadata": {},
1602 "output_type": "execute_result"
1603 }
1604 ],
1605 "source": [
1606 "wheel_6 = Wheel(wheel_vi_spec, wheel_vi_notches, position='b', ring_setting=3)\n",
1607 "wheel_6.notch_positions"
1608 ]
1609 },
1610 {
1611 "cell_type": "code",
1612 "execution_count": 164,
1613 "metadata": {
1614 "collapsed": true
1615 },
1616 "outputs": [],
1617 "source": [
1618 "wheel_6 = Wheel(wheel_vi_spec, wheel_vi_notches, position='b', ring_setting=3)\n",
1619 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'xkqhwpvngzrcfoiaselbtymjdu')\n",
1620 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'ptlyrmidoxbswhnfckquzgeavj')\n",
1621 "assert(wheel_6.position == 25)\n",
1622 "assert(2 in wheel_6.notch_positions)\n",
1623 "assert(15 in wheel_6.notch_positions)\n",
1624 "assert(wheel_6.position_l == 'b')\n",
1625 "\n",
1626 "wheel_6.advance()\n",
1627 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'jpgvoumfyqbenhzrdkasxlictw')\n",
1628 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'skxqlhcnwarvgmebjptyfdzuio')\n",
1629 "assert(wheel_6.position == 0)\n",
1630 "assert(3 in wheel_6.notch_positions)\n",
1631 "assert(16 in wheel_6.notch_positions)\n",
1632 "assert(wheel_6.position_l == 'c')\n",
1633 "\n",
1634 "for _ in range(22): wheel_6.advance()\n",
1635 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'mgxantkzsyqjcufirldvhoewbp')\n",
1636 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'dymswobuplgraevzkqifntxcjh')\n",
1637 "assert(wheel_6.position == 22)\n",
1638 "assert(25 in wheel_6.notch_positions)\n",
1639 "assert(12 in wheel_6.notch_positions)\n",
1640 "assert(wheel_6.position_l == 'y')\n",
1641 "\n",
1642 "wheel_6.advance()\n",
1643 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'fwzmsjyrxpibtehqkcugndvaol')\n",
1644 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'xlrvnatokfqzduyjphemswbigc')\n",
1645 "assert(wheel_6.position == 23)\n",
1646 "assert(0 in wheel_6.notch_positions)\n",
1647 "assert(13 in wheel_6.notch_positions)\n",
1648 "assert(wheel_6.position_l == 'z')\n",
1649 "\n",
1650 "wheel_6.advance()\n",
1651 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'vylrixqwohasdgpjbtfmcuznke')\n",
1652 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'kqumzsnjepyctxiogdlrvahfbw')\n",
1653 "assert(wheel_6.position == 24)\n",
1654 "assert(1 in wheel_6.notch_positions)\n",
1655 "assert(14 in wheel_6.notch_positions)\n",
1656 "assert(wheel_6.position_l == 'a')\n",
1657 "\n",
1658 "wheel_6.advance()\n",
1659 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'xkqhwpvngzrcfoiaselbtymjdu')\n",
1660 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'ptlyrmidoxbswhnfckquzgeavj')\n",
1661 "assert(wheel_6.position == 25)\n",
1662 "assert(2 in wheel_6.notch_positions)\n",
1663 "assert(15 in wheel_6.notch_positions)\n",
1664 "assert(wheel_6.position_l == 'b')\n",
1665 "\n",
1666 "wheel_6.advance()\n",
1667 "assert(cat(wheel_6.forward(l) for l in string.ascii_lowercase) == 'jpgvoumfyqbenhzrdkasxlictw')\n",
1668 "assert(cat(wheel_6.backward(l) for l in string.ascii_lowercase) == 'skxqlhcnwarvgmebjptyfdzuio')\n",
1669 "assert(wheel_6.position == 0)\n",
1670 "assert(3 in wheel_6.notch_positions)\n",
1671 "assert(16 in wheel_6.notch_positions)\n",
1672 "assert(wheel_6.position_l == 'c')"
1673 ]
1674 },
1675 {
1676 "cell_type": "code",
1677 "execution_count": 165,
1678 "metadata": {},
1679 "outputs": [
1680 {
1681 "data": {
1682 "text/plain": [
1683 "(0, 'c', [3, 16])"
1684 ]
1685 },
1686 "execution_count": 165,
1687 "metadata": {},
1688 "output_type": "execute_result"
1689 }
1690 ],
1691 "source": [
1692 "wheel_6.position, wheel_6.position_l, wheel_6.notch_positions"
1693 ]
1694 },
1695 {
1696 "cell_type": "markdown",
1697 "metadata": {},
1698 "source": [
1699 "<a name=\"enigma\"></a>\n",
1700 "## Enigma\n",
1701 "[Top](#top)\n",
1702 "\n",
1703 "This is the full Enigma machine.\n",
1704 "\n",
1705 "It's a collection of the various components defined above. There are three wheels (left, middle, and right), a plugboard, and a reflector.\n",
1706 "\n",
1707 "The `__getattribute__` method returns the state of the machine in friendly form, generally by asking the components to return the relevant attributes."
1708 ]
1709 },
1710 {
1711 "cell_type": "code",
1712 "execution_count": 167,
1713 "metadata": {},
1714 "outputs": [],
1715 "source": [
1716 "class Enigma(object):\n",
1717 " def __init__(self, reflector_spec,\n",
1718 " left_wheel_spec, left_wheel_notches,\n",
1719 " middle_wheel_spec, middle_wheel_notches,\n",
1720 " right_wheel_spec, right_wheel_notches,\n",
1721 " left_ring_setting, middle_ring_setting, right_ring_setting,\n",
1722 " plugboard_setting):\n",
1723 " self.reflector = Reflector(reflector_spec)\n",
1724 " self.left_wheel = Wheel(left_wheel_spec, left_wheel_notches, ring_setting=left_ring_setting)\n",
1725 " self.middle_wheel = Wheel(middle_wheel_spec, middle_wheel_notches, ring_setting=middle_ring_setting)\n",
1726 " self.right_wheel = Wheel(right_wheel_spec, right_wheel_notches, ring_setting=right_ring_setting)\n",
1727 " self.plugboard = Plugboard(plugboard_setting)\n",
1728 " \n",
1729 " def __getattribute__(self,name):\n",
1730 " if name=='wheel_positions':\n",
1731 " return self.left_wheel.position, self.middle_wheel.position, self.right_wheel.position \n",
1732 " elif name=='wheel_positions_l':\n",
1733 " return self.left_wheel.position_l, self.middle_wheel.position_l, self.right_wheel.position_l \n",
1734 " elif name=='notch_positions':\n",
1735 " return (self.left_wheel.notch_positions, \n",
1736 " self.middle_wheel.notch_positions, \n",
1737 " self.right_wheel.notch_positions)\n",
1738 " else:\n",
1739 " return object.__getattribute__(self, name)"
1740 ]
1741 },
1742 {
1743 "cell_type": "markdown",
1744 "metadata": {},
1745 "source": [
1746 "Set the wheels to the initial positions. "
1747 ]
1748 },
1749 {
1750 "cell_type": "code",
1751 "execution_count": 168,
1752 "metadata": {
1753 "collapsed": true
1754 },
1755 "outputs": [],
1756 "source": [
1757 "def set_wheels(self, left_wheel_position, middle_wheel_position, right_wheel_position):\n",
1758 " self.left_wheel.set_position(left_wheel_position)\n",
1759 " self.middle_wheel.set_position(middle_wheel_position)\n",
1760 " self.right_wheel.set_position(right_wheel_position)\n",
1761 "\n",
1762 "setattr(Enigma, 'set_wheels', set_wheels)"
1763 ]
1764 },
1765 {
1766 "cell_type": "markdown",
1767 "metadata": {},
1768 "source": [
1769 "`lookup` just follows a path through the machine without changing the positions of any parts. It just follows a signal from the input, thorough all the components, to the reflector, back through all the components, to the output."
1770 ]
1771 },
1772 {
1773 "cell_type": "code",
1774 "execution_count": 169,
1775 "metadata": {
1776 "collapsed": true
1777 },
1778 "outputs": [],
1779 "source": [
1780 "def lookup(self, letter):\n",
1781 " a = self.plugboard.forward(letter)\n",
1782 " b = self.right_wheel.forward(a)\n",
1783 " c = self.middle_wheel.forward(b)\n",
1784 " d = self.left_wheel.forward(c)\n",
1785 " e = self.reflector.forward(d)\n",
1786 " f = self.left_wheel.backward(e)\n",
1787 " g = self.middle_wheel.backward(f)\n",
1788 " h = self.right_wheel.backward(g)\n",
1789 " i = self.plugboard.backward(h)\n",
1790 " return i\n",
1791 "\n",
1792 "setattr(Enigma, 'lookup', lookup)"
1793 ]
1794 },
1795 {
1796 "cell_type": "markdown",
1797 "metadata": {},
1798 "source": [
1799 "`advance` moves the wheels on one step. The right wheel always advances. If the notch is in the zero position, the wheel also advances the wheel to the left. \n",
1800 "\n",
1801 "It follows the 'double stepping' behaviour of the engima machines."
1802 ]
1803 },
1804 {
1805 "cell_type": "code",
1806 "execution_count": 170,
1807 "metadata": {
1808 "collapsed": true
1809 },
1810 "outputs": [],
1811 "source": [
1812 "def advance(self):\n",
1813 " advance_middle = False\n",
1814 " advance_left = False\n",
1815 " if 0 in self.right_wheel.notch_positions:\n",
1816 " advance_middle = True\n",
1817 " if 0 in self.middle_wheel.notch_positions:\n",
1818 " advance_left = True\n",
1819 " advance_middle = True\n",
1820 " self.right_wheel.advance()\n",
1821 " if advance_middle: self.middle_wheel.advance()\n",
1822 " if advance_left: self.left_wheel.advance()\n",
1823 "\n",
1824 "setattr(Enigma, 'advance', advance) "
1825 ]
1826 },
1827 {
1828 "cell_type": "markdown",
1829 "metadata": {},
1830 "source": [
1831 "Finally, encipher letters and messages. \n",
1832 "\n",
1833 "Note that the wheels advance _before_ the letter signal is sent through the machine: in the physical machine, the advancing is done by pressing the key on the keyboard. \n",
1834 "\n",
1835 "Also note that the messages are cleaned before use, so letters are converted to lower case and non-letters are removed."
1836 ]
1837 },
1838 {
1839 "cell_type": "code",
1840 "execution_count": 220,
1841 "metadata": {
1842 "collapsed": true
1843 },
1844 "outputs": [],
1845 "source": [
1846 "def encipher_letter(self, letter):\n",
1847 " self.advance()\n",
1848 " return self.lookup(letter)\n",
1849 "\n",
1850 "def encipher(self, message, debug=False):\n",
1851 " enciphered = ''\n",
1852 " for letter in clean(message):\n",
1853 " enciphered += self.encipher_letter(letter)\n",
1854 " if debug:\n",
1855 " print('Wheels now', list(self.wheel_positions_l), 'enciphering {} -> {}'.format(letter, self.lookup(letter)))\n",
1856 " return enciphered\n",
1857 "\n",
1858 "setattr(Enigma, 'encipher_letter', encipher_letter)\n",
1859 "setattr(Enigma, 'encipher', encipher)\n",
1860 "setattr(Enigma, 'decipher', encipher)"
1861 ]
1862 },
1863 {
1864 "cell_type": "markdown",
1865 "metadata": {},
1866 "source": [
1867 "<a name=\"testingenigma\"></a>\n",
1868 "## Testing Enigma\n",
1869 "[Top](#top)\n",
1870 "\n",
1871 "Some tests of the Enigma machine."
1872 ]
1873 },
1874 {
1875 "cell_type": "code",
1876 "execution_count": 172,
1877 "metadata": {
1878 "collapsed": true
1879 },
1880 "outputs": [],
1881 "source": [
1882 "enigma = Enigma(reflector_b_spec, \n",
1883 " wheel_i_spec, wheel_i_notches,\n",
1884 " wheel_ii_spec, wheel_ii_notches,\n",
1885 " wheel_iii_spec, wheel_iii_notches,\n",
1886 " 1, 1, 1,\n",
1887 " '')"
1888 ]
1889 },
1890 {
1891 "cell_type": "code",
1892 "execution_count": 173,
1893 "metadata": {},
1894 "outputs": [
1895 {
1896 "data": {
1897 "text/plain": [
1898 "'u'"
1899 ]
1900 },
1901 "execution_count": 173,
1902 "metadata": {},
1903 "output_type": "execute_result"
1904 }
1905 ],
1906 "source": [
1907 "enigma.lookup('a')"
1908 ]
1909 },
1910 {
1911 "cell_type": "code",
1912 "execution_count": 174,
1913 "metadata": {},
1914 "outputs": [
1915 {
1916 "data": {
1917 "text/plain": [
1918 "'a'"
1919 ]
1920 },
1921 "execution_count": 174,
1922 "metadata": {},
1923 "output_type": "execute_result"
1924 }
1925 ],
1926 "source": [
1927 "enigma.lookup('u')"
1928 ]
1929 },
1930 {
1931 "cell_type": "code",
1932 "execution_count": 175,
1933 "metadata": {},
1934 "outputs": [
1935 {
1936 "data": {
1937 "text/plain": [
1938 "'uejobtpzwcnsrkdgvmlfaqiyxh'"
1939 ]
1940 },
1941 "execution_count": 175,
1942 "metadata": {},
1943 "output_type": "execute_result"
1944 }
1945 ],
1946 "source": [
1947 "cat(enigma.lookup(l) for l in string.ascii_lowercase)"
1948 ]
1949 },
1950 {
1951 "cell_type": "code",
1952 "execution_count": 176,
1953 "metadata": {},
1954 "outputs": [
1955 {
1956 "data": {
1957 "text/plain": [
1958 "'abcdefghijklmnopqrstuvwxyz'"
1959 ]
1960 },
1961 "execution_count": 176,
1962 "metadata": {},
1963 "output_type": "execute_result"
1964 }
1965 ],
1966 "source": [
1967 "cat(enigma.lookup(enigma.lookup(l)) for l in string.ascii_lowercase)"
1968 ]
1969 },
1970 {
1971 "cell_type": "code",
1972 "execution_count": 177,
1973 "metadata": {
1974 "collapsed": true
1975 },
1976 "outputs": [],
1977 "source": [
1978 "assert(cat(enigma.lookup(enigma.lookup(l)) for l in string.ascii_lowercase) == string.ascii_lowercase)"
1979 ]
1980 },
1981 {
1982 "cell_type": "code",
1983 "execution_count": 178,
1984 "metadata": {
1985 "scrolled": true
1986 },
1987 "outputs": [
1988 {
1989 "name": "stdout",
1990 "output_type": "stream",
1991 "text": [
1992 "0 :: a a a ; [10] [22] [5] uejobtpzwcnsrkdgvmlfaqiyxh\n",
1993 "1 :: a a b ; [10] [22] [6] baqmfexihswpdytlcvjozrkgnu\n",
1994 "2 :: a a c ; [10] [22] [7] djralkwpobfeyqihncxzvugsmt\n",
1995 "3 :: a a d ; [10] [22] [8] zlejcuitgdmbkonsvxphfqyrwa\n",
1996 "4 :: a a e ; [10] [22] [9] gcblwtakqzhdosmxiunfryepvj\n",
1997 "5 :: a a f ; [10] [22] [10] osnirgfmdpvuhcajwebxlkqtzy\n",
1998 "6 :: a a g ; [10] [22] [11] wymvnqzjlhoicekuftxrpdasbg\n",
1999 "7 :: a a h ; [10] [22] [12] cjafkdztpbeuormiwnvhlsqyxg\n",
2000 "8 :: a a i ; [10] [22] [13] xijuyslvbczgnmqwotfrdhpaek\n",
2001 "9 :: a a j ; [10] [22] [14] lfzrwbytjisaovmuxdkhpneqgc\n",
2002 "10 :: a a k ; [10] [22] [15] tkezcqynuwbpvhslfxoaimjrgd\n",
2003 "11 :: a a l ; [10] [22] [16] kiwfnduxbsaotelqpvjmgrchzy\n",
2004 "12 :: a a m ; [10] [22] [17] sfkutbpoxycrnmhgwlaedzqijv\n",
2005 "13 :: a a n ; [10] [22] [18] baqwlkhgrsfextpocijnvudmzy\n",
2006 "14 :: a a o ; [10] [22] [19] teofbdzxqkjyrscvimnawpuhlg\n",
2007 "15 :: a a p ; [10] [22] [20] mhypswrbzxqvaondkgeutlfjci\n",
2008 "16 :: a a q ; [10] [22] [21] cpasnrhgkuixzevbyfdwjotlqm\n",
2009 "17 :: a a r ; [10] [22] [22] dlfatcjwygvbnmzrxpueskhqio\n",
2010 "18 :: a a s ; [10] [22] [23] lxymzjuqtfpadsrkhonigwvbce\n",
2011 "19 :: a a t ; [10] [22] [24] puvioztjdhxmlyeawsrgbcqknf\n",
2012 "20 :: a a u ; [10] [22] [25] baigpldqcowfyzjehvtsxrkumn\n",
2013 "21 :: a a v ; [10] [22] [0] mnvfydiwgzsoablrxpkutchqej\n",
2014 "22 :: a b w ; [10] [23] [1] ulfopcykswhbzvderqixanjtgm\n",
2015 "23 :: a b x ; [10] [23] [2] qmwftdyovursbzhxaklejicpgn\n",
2016 "24 :: a b y ; [10] [23] [3] oljmzxrvucybdqasngpwihtfke\n",
2017 "25 :: a b z ; [10] [23] [4] fwevcalzxutgysrqponkjdbimh\n"
2018 ]
2019 }
2020 ],
2021 "source": [
2022 "# check the middle wheel turns over\n",
2023 "enigma.set_wheels('a', 'a', 'a')\n",
2024 "for i in range(26):\n",
2025 " print(i, '::', \n",
2026 " enigma.left_wheel.position_l, enigma.middle_wheel.position_l, enigma.right_wheel.position_l, ';',\n",
2027 " enigma.left_wheel.notch_positions, enigma.middle_wheel.notch_positions, enigma.right_wheel.notch_positions, \n",
2028 " cat(enigma.lookup(l) for l in string.ascii_lowercase))\n",
2029 " enigma.advance()"
2030 ]
2031 },
2032 {
2033 "cell_type": "markdown",
2034 "metadata": {},
2035 "source": [
2036 "Formal test of middle wheel turnover"
2037 ]
2038 },
2039 {
2040 "cell_type": "code",
2041 "execution_count": 179,
2042 "metadata": {
2043 "collapsed": true,
2044 "scrolled": true
2045 },
2046 "outputs": [],
2047 "source": [
2048 "enigma.set_wheels('a', 'a', 't')\n",
2049 "assert(enigma.wheel_positions == (0, 0, 19))\n",
2050 "assert(cat(enigma.wheel_positions_l) == 'aat')\n",
2051 "assert(enigma.notch_positions == ([10], [22], [24]))\n",
2052 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'puvioztjdhxmlyeawsrgbcqknf')\n",
2053 "\n",
2054 "enigma.advance()\n",
2055 "assert(enigma.wheel_positions == (0, 0, 20))\n",
2056 "assert(cat(enigma.wheel_positions_l) == 'aau')\n",
2057 "assert(enigma.notch_positions == ([10], [22], [25]))\n",
2058 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'baigpldqcowfyzjehvtsxrkumn')\n",
2059 "\n",
2060 "enigma.advance()\n",
2061 "assert(enigma.wheel_positions == (0, 0, 21))\n",
2062 "assert(cat(enigma.wheel_positions_l) == 'aav')\n",
2063 "assert(enigma.notch_positions == ([10], [22], [0]))\n",
2064 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'mnvfydiwgzsoablrxpkutchqej')\n",
2065 "\n",
2066 "enigma.advance()\n",
2067 "assert(enigma.wheel_positions == (0, 1, 22))\n",
2068 "assert(cat(enigma.wheel_positions_l) == 'abw')\n",
2069 "assert(enigma.notch_positions == ([10], [23], [1]))\n",
2070 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'ulfopcykswhbzvderqixanjtgm')\n",
2071 "\n",
2072 "enigma.advance()\n",
2073 "assert(enigma.wheel_positions == (0, 1, 23))\n",
2074 "assert(cat(enigma.wheel_positions_l) == 'abx')\n",
2075 "assert(enigma.notch_positions == ([10], [23], [2]))\n",
2076 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'qmwftdyovursbzhxaklejicpgn')\n",
2077 "\n",
2078 "enigma.advance()\n",
2079 "assert(enigma.wheel_positions == (0, 1, 24))\n",
2080 "assert(cat(enigma.wheel_positions_l) == 'aby')\n",
2081 "assert(enigma.notch_positions == ([10], [23 ], [3]))\n",
2082 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'oljmzxrvucybdqasngpwihtfke')\n"
2083 ]
2084 },
2085 {
2086 "cell_type": "markdown",
2087 "metadata": {},
2088 "source": [
2089 "Test of middle wheel advancing the left wheel, exhibiting the \"double step\" behaviour."
2090 ]
2091 },
2092 {
2093 "cell_type": "code",
2094 "execution_count": 180,
2095 "metadata": {
2096 "scrolled": true
2097 },
2098 "outputs": [
2099 {
2100 "name": "stdout",
2101 "output_type": "stream",
2102 "text": [
2103 "(1, 5, 24) ('b', 'f', 'y') ([11], [1], [3]) baknstqzrmcxjdvygiefwoulph\n"
2104 ]
2105 }
2106 ],
2107 "source": [
2108 "enigma.set_wheels('a', 'd', 't')\n",
2109 "assert(enigma.wheel_positions == (0, 3, 19))\n",
2110 "assert(cat(enigma.wheel_positions_l) == 'adt')\n",
2111 "assert(enigma.notch_positions == ([10], [25], [24]))\n",
2112 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'zcbpqxwsjiuonmldethrkygfva')\n",
2113 "\n",
2114 "enigma.advance()\n",
2115 "assert(enigma.wheel_positions == (0, 3, 20))\n",
2116 "assert(cat(enigma.wheel_positions_l) == 'adu')\n",
2117 "assert(enigma.notch_positions == ([10], [25], [25]))\n",
2118 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'ehprawjbngotxikcsdqlzyfmvu')\n",
2119 "\n",
2120 "enigma.advance()\n",
2121 "assert(enigma.wheel_positions == (0, 3, 21))\n",
2122 "assert(cat(enigma.wheel_positions_l) == 'adv')\n",
2123 "assert(enigma.notch_positions == ([10], [25], [0]))\n",
2124 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'eqzxarpihmnvjkwgbfuyslodtc')\n",
2125 "\n",
2126 "enigma.advance()\n",
2127 "assert(enigma.wheel_positions == (0, 4, 22))\n",
2128 "assert(cat(enigma.wheel_positions_l) == 'aew')\n",
2129 "assert(enigma.notch_positions == ([10], [0], [1]))\n",
2130 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'qedcbtpluzmhkongavwfirsyxj')\n",
2131 "\n",
2132 "enigma.advance()\n",
2133 "assert(enigma.wheel_positions == (1, 5, 23))\n",
2134 "assert(cat(enigma.wheel_positions_l) == 'bfx')\n",
2135 "assert(enigma.notch_positions == ([11], [1], [2]))\n",
2136 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'iwuedhsfazqxytvrkpgncoblmj')\n",
2137 "\n",
2138 "enigma.advance()\n",
2139 "assert(enigma.wheel_positions == (1, 5, 24))\n",
2140 "assert(cat(enigma.wheel_positions_l) == 'bfy')\n",
2141 "assert(enigma.notch_positions == ([11], [1], [3]))\n",
2142 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'baknstqzrmcxjdvygiefwoulph')\n",
2143 "\n",
2144 "print(enigma.wheel_positions, enigma.wheel_positions_l, enigma.notch_positions, \n",
2145 " cat(enigma.lookup(l) for l in string.ascii_lowercase))\n"
2146 ]
2147 },
2148 {
2149 "cell_type": "code",
2150 "execution_count": 181,
2151 "metadata": {},
2152 "outputs": [
2153 {
2154 "data": {
2155 "text/plain": [
2156 "'olpfhnvflyn'"
2157 ]
2158 },
2159 "execution_count": 181,
2160 "metadata": {},
2161 "output_type": "execute_result"
2162 }
2163 ],
2164 "source": [
2165 "enigma.set_wheels('a', 'a', 'a')\n",
2166 "ct = enigma.encipher('testmessage')\n",
2167 "assert(ct == 'olpfhnvflyn')\n",
2168 "ct"
2169 ]
2170 },
2171 {
2172 "cell_type": "code",
2173 "execution_count": 182,
2174 "metadata": {},
2175 "outputs": [
2176 {
2177 "data": {
2178 "text/plain": [
2179 "'lawnjgpwjik'"
2180 ]
2181 },
2182 "execution_count": 182,
2183 "metadata": {},
2184 "output_type": "execute_result"
2185 }
2186 ],
2187 "source": [
2188 "enigma.set_wheels('a', 'd', 't')\n",
2189 "ct = enigma.encipher('testmessage')\n",
2190 "assert(ct == 'lawnjgpwjik')\n",
2191 "ct"
2192 ]
2193 },
2194 {
2195 "cell_type": "code",
2196 "execution_count": 183,
2197 "metadata": {},
2198 "outputs": [
2199 {
2200 "name": "stdout",
2201 "output_type": "stream",
2202 "text": [
2203 "enigma.advance()\n",
2204 "assert(enigma.wheel_positions == (0, 3, 20))\n",
2205 "assert(cat(enigma.wheel_positions_l) == 'adu')\n",
2206 "assert(enigma.notch_positions == ([10], [25], [25]))\n",
2207 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'ehprawjbngotxikcsdqlzyfmvu')\n",
2208 "\n",
2209 "enigma.advance()\n",
2210 "assert(enigma.wheel_positions == (0, 3, 21))\n",
2211 "assert(cat(enigma.wheel_positions_l) == 'adv')\n",
2212 "assert(enigma.notch_positions == ([10], [25], [0]))\n",
2213 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'eqzxarpihmnvjkwgbfuyslodtc')\n",
2214 "\n",
2215 "enigma.advance()\n",
2216 "assert(enigma.wheel_positions == (0, 4, 22))\n",
2217 "assert(cat(enigma.wheel_positions_l) == 'aew')\n",
2218 "assert(enigma.notch_positions == ([10], [0], [1]))\n",
2219 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'qedcbtpluzmhkongavwfirsyxj')\n",
2220 "\n",
2221 "enigma.advance()\n",
2222 "assert(enigma.wheel_positions == (1, 5, 23))\n",
2223 "assert(cat(enigma.wheel_positions_l) == 'bfx')\n",
2224 "assert(enigma.notch_positions == ([11], [1], [2]))\n",
2225 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'iwuedhsfazqxytvrkpgncoblmj')\n",
2226 "\n",
2227 "enigma.advance()\n",
2228 "assert(enigma.wheel_positions == (1, 5, 24))\n",
2229 "assert(cat(enigma.wheel_positions_l) == 'bfy')\n",
2230 "assert(enigma.notch_positions == ([11], [1], [3]))\n",
2231 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'baknstqzrmcxjdvygiefwoulph')\n",
2232 "\n",
2233 "enigma.advance()\n",
2234 "assert(enigma.wheel_positions == (1, 5, 25))\n",
2235 "assert(cat(enigma.wheel_positions_l) == 'bfz')\n",
2236 "assert(enigma.notch_positions == ([11], [1], [4]))\n",
2237 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'mudcgteyjiwravxzslqfbnkohp')\n",
2238 "\n",
2239 "enigma.advance()\n",
2240 "assert(enigma.wheel_positions == (1, 5, 0))\n",
2241 "assert(cat(enigma.wheel_positions_l) == 'bfa')\n",
2242 "assert(enigma.notch_positions == ([11], [1], [5]))\n",
2243 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'gjkuotarmbcziwesvhpfdqnyxl')\n",
2244 "\n",
2245 "enigma.advance()\n",
2246 "assert(enigma.wheel_positions == (1, 5, 1))\n",
2247 "assert(cat(enigma.wheel_positions_l) == 'bfb')\n",
2248 "assert(enigma.notch_positions == ([11], [1], [6]))\n",
2249 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'fcbmpaqihxytdrvegnwlzosjku')\n",
2250 "\n",
2251 "enigma.advance()\n",
2252 "assert(enigma.wheel_positions == (1, 5, 2))\n",
2253 "assert(cat(enigma.wheel_positions_l) == 'bfc')\n",
2254 "assert(enigma.notch_positions == ([11], [1], [7]))\n",
2255 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'jktrlpmywabegzqfodxcvuishn')\n",
2256 "\n",
2257 "enigma.advance()\n",
2258 "assert(enigma.wheel_positions == (1, 5, 3))\n",
2259 "assert(cat(enigma.wheel_positions_l) == 'bfd')\n",
2260 "assert(enigma.notch_positions == ([11], [1], [8]))\n",
2261 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'baetclivgurfzqponkxdjhyswm')\n",
2262 "\n",
2263 "enigma.advance()\n",
2264 "assert(enigma.wheel_positions == (1, 5, 4))\n",
2265 "assert(cat(enigma.wheel_positions_l) == 'bfe')\n",
2266 "assert(enigma.notch_positions == ([11], [1], [9]))\n",
2267 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'wvjlkpzxtcedqsyfmunirbahog')\n",
2268 "\n",
2269 "enigma.advance()\n",
2270 "assert(enigma.wheel_positions == (1, 5, 5))\n",
2271 "assert(cat(enigma.wheel_positions_l) == 'bff')\n",
2272 "assert(enigma.notch_positions == ([11], [1], [10]))\n",
2273 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'zpqiogfsdlmjkyebcvhxwrutna')\n",
2274 "\n",
2275 "enigma.advance()\n",
2276 "assert(enigma.wheel_positions == (1, 5, 6))\n",
2277 "assert(cat(enigma.wheel_positions_l) == 'bfg')\n",
2278 "assert(enigma.notch_positions == ([11], [1], [11]))\n",
2279 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'fjmnwayslbxicdpouthrqzekgv')\n",
2280 "\n",
2281 "enigma.advance()\n",
2282 "assert(enigma.wheel_positions == (1, 5, 7))\n",
2283 "assert(cat(enigma.wheel_positions_l) == 'bfh')\n",
2284 "assert(enigma.notch_positions == ([11], [1], [12]))\n",
2285 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'csafzdyloxuhnmitwvbpkrqjge')\n",
2286 "\n",
2287 "enigma.advance()\n",
2288 "assert(enigma.wheel_positions == (1, 5, 8))\n",
2289 "assert(cat(enigma.wheel_positions_l) == 'bfi')\n",
2290 "assert(enigma.notch_positions == ([11], [1], [13]))\n",
2291 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'kihyvulcbtagwrqzonxjfemsdp')\n",
2292 "\n",
2293 "enigma.advance()\n",
2294 "assert(enigma.wheel_positions == (1, 5, 9))\n",
2295 "assert(cat(enigma.wheel_positions_l) == 'bfj')\n",
2296 "assert(enigma.notch_positions == ([11], [1], [14]))\n",
2297 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'pgzrytbksqhwxvuajdifonlmec')\n",
2298 "\n",
2299 "enigma.advance()\n",
2300 "assert(enigma.wheel_positions == (1, 5, 10))\n",
2301 "assert(cat(enigma.wheel_positions_l) == 'bfk')\n",
2302 "assert(enigma.notch_positions == ([11], [1], [15]))\n",
2303 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'fkirsazncwbvyhpoudexqljtmg')\n",
2304 "\n",
2305 "enigma.advance()\n",
2306 "assert(enigma.wheel_positions == (1, 5, 11))\n",
2307 "assert(cat(enigma.wheel_positions_l) == 'bfl')\n",
2308 "assert(enigma.notch_positions == ([11], [1], [16]))\n",
2309 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'mhkronubsvctafeqpdilgjxwzy')\n",
2310 "\n",
2311 "enigma.advance()\n",
2312 "assert(enigma.wheel_positions == (1, 5, 12))\n",
2313 "assert(cat(enigma.wheel_positions_l) == 'bfm')\n",
2314 "assert(enigma.notch_positions == ([11], [1], [17]))\n",
2315 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'gnkuoxarzycmlbetvhwpdqsfji')\n",
2316 "\n",
2317 "enigma.advance()\n",
2318 "assert(enigma.wheel_positions == (1, 5, 13))\n",
2319 "assert(cat(enigma.wheel_positions_l) == 'bfn')\n",
2320 "assert(enigma.notch_positions == ([11], [1], [18]))\n",
2321 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'bainslqkcxhfudpogtermwvjzy')\n",
2322 "\n",
2323 "enigma.advance()\n",
2324 "assert(enigma.wheel_positions == (1, 5, 14))\n",
2325 "assert(cat(enigma.wheel_positions_l) == 'bfo')\n",
2326 "assert(enigma.notch_positions == ([11], [1], [19]))\n",
2327 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'xemfbdnwjitycgzusvqkprhalo')\n",
2328 "\n",
2329 "enigma.advance()\n",
2330 "assert(enigma.wheel_positions == (1, 5, 15))\n",
2331 "assert(cat(enigma.wheel_positions_l) == 'bfp')\n",
2332 "assert(enigma.notch_positions == ([11], [1], [20]))\n",
2333 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'qixksmhgbtdvfonrapejwluczy')\n",
2334 "\n",
2335 "enigma.advance()\n",
2336 "assert(enigma.wheel_positions == (1, 5, 16))\n",
2337 "assert(cat(enigma.wheel_positions_l) == 'bfq')\n",
2338 "assert(enigma.notch_positions == ([11], [1], [21]))\n",
2339 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'cgaulmbskwiefrtzynhodxjvqp')\n",
2340 "\n",
2341 "enigma.advance()\n",
2342 "assert(enigma.wheel_positions == (1, 5, 17))\n",
2343 "assert(cat(enigma.wheel_positions_l) == 'bfr')\n",
2344 "assert(enigma.notch_positions == ([11], [1], [22]))\n",
2345 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'iwqfldszaxvenmyrcpgutkbjoh')\n",
2346 "\n",
2347 "enigma.advance()\n",
2348 "assert(enigma.wheel_positions == (1, 5, 18))\n",
2349 "assert(cat(enigma.wheel_positions_l) == 'bfs')\n",
2350 "assert(enigma.notch_positions == ([11], [1], [23]))\n",
2351 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'vxykrjilgfdhqtusmepnoazbcw')\n",
2352 "\n",
2353 "enigma.advance()\n",
2354 "assert(enigma.wheel_positions == (1, 5, 19))\n",
2355 "assert(cat(enigma.wheel_positions_l) == 'bft')\n",
2356 "assert(enigma.notch_positions == ([11], [1], [24]))\n",
2357 "assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == 'ieysbvkjahgmlpxnwtdrzfqocu')\n",
2358 "\n"
2359 ]
2360 }
2361 ],
2362 "source": [
2363 "enigma.set_wheels('a', 'd', 't')\n",
2364 "for i in range(26):\n",
2365 " enigma.advance()\n",
2366 " print('enigma.advance()')\n",
2367 " print(\"assert(enigma.wheel_positions == {})\".format(enigma.wheel_positions))\n",
2368 " print(\"assert(cat(enigma.wheel_positions_l) == '{}')\".format(cat(enigma.wheel_positions_l)))\n",
2369 " print(\"assert(enigma.notch_positions == {})\".format(enigma.notch_positions))\n",
2370 " print(\"assert(cat(enigma.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(enigma.lookup(l) for l in string.ascii_lowercase)))\n",
2371 " print()"
2372 ]
2373 },
2374 {
2375 "cell_type": "code",
2376 "execution_count": 184,
2377 "metadata": {},
2378 "outputs": [
2379 {
2380 "data": {
2381 "text/plain": [
2382 "'bahxvfrpdc'"
2383 ]
2384 },
2385 "execution_count": 184,
2386 "metadata": {},
2387 "output_type": "execute_result"
2388 }
2389 ],
2390 "source": [
2391 "enigma.set_wheels('a', 'd', 't')\n",
2392 "ct = enigma.encipher('hellothere')\n",
2393 "assert(ct == 'bahxvfrpdc')\n",
2394 "ct"
2395 ]
2396 },
2397 {
2398 "cell_type": "code",
2399 "execution_count": 185,
2400 "metadata": {},
2401 "outputs": [
2402 {
2403 "data": {
2404 "text/plain": [
2405 "'kvmmwrlqlqsqpeugjrcxzwpfyiyybwloewrouvkpoztceuwtfjzqwpbqldttsr'"
2406 ]
2407 },
2408 "execution_count": 185,
2409 "metadata": {},
2410 "output_type": "execute_result"
2411 }
2412 ],
2413 "source": [
2414 "enigma.set_wheels('b', 'd', 'q')\n",
2415 "ct = enigma.encipher('aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa')\n",
2416 "assert(ct == 'kvmmwrlqlqsqpeugjrcxzwpfyiyybwloewrouvkpoztceuwtfjzqwpbqldttsr')\n",
2417 "assert(enigma.left_wheel.position_l == 'c')\n",
2418 "assert(enigma.middle_wheel.position_l == 'h')\n",
2419 "assert(enigma.right_wheel.position_l == 'a')\n",
2420 "ct"
2421 ]
2422 },
2423 {
2424 "cell_type": "code",
2425 "execution_count": 186,
2426 "metadata": {},
2427 "outputs": [
2428 {
2429 "data": {
2430 "text/plain": [
2431 "'c'"
2432 ]
2433 },
2434 "execution_count": 186,
2435 "metadata": {},
2436 "output_type": "execute_result"
2437 }
2438 ],
2439 "source": [
2440 "enigma.left_wheel.position_l"
2441 ]
2442 },
2443 {
2444 "cell_type": "code",
2445 "execution_count": 187,
2446 "metadata": {
2447 "collapsed": true
2448 },
2449 "outputs": [],
2450 "source": [
2451 "# Setting sheet line 31 from http://www.codesandciphers.org.uk/enigma/enigma3.htm\n",
2452 "# Enigma simulation settings are \n",
2453 "# http://enigma.louisedade.co.uk/enigma.html?m3;b;b153;AFTX;AJFE;AU-BG-EY-FP-HL-IN-JZ-OS-QR-TX\n",
2454 "w_enigma = Enigma(reflector_b_spec, \n",
2455 " wheel_i_spec, wheel_i_notches,\n",
2456 " wheel_v_spec, wheel_v_notches,\n",
2457 " wheel_iii_spec, wheel_iii_notches,\n",
2458 " 6, 20, 24,\n",
2459 " 'ua pf rq so ni ey bg hl tx zj')"
2460 ]
2461 },
2462 {
2463 "cell_type": "code",
2464 "execution_count": 188,
2465 "metadata": {
2466 "collapsed": true
2467 },
2468 "outputs": [],
2469 "source": [
2470 "# # Setting sheet line 31 from http://www.codesandciphers.org.uk/enigma/enigma3.htm\n",
2471 "# # Enigma simulation settings are \n",
2472 "# # http://enigma.louisedade.co.uk/enigma.html?m3;b;b153;AFTX;AJFE;AU-BG-EY-FP-HL-IN-JZ-OS-QR-TX\n",
2473 "# enigma = Enigma(reflector_b_spec, \n",
2474 "# wheel_i_spec, wheel_i_notches,\n",
2475 "# wheel_v_spec, wheel_v_notches,\n",
2476 "# wheel_iii_spec, wheel_iii_notches,\n",
2477 "# 6, 20, 24,\n",
2478 "# 'ua pf rq so ni ey bg hl tx zj')"
2479 ]
2480 },
2481 {
2482 "cell_type": "code",
2483 "execution_count": 189,
2484 "metadata": {
2485 "collapsed": true
2486 },
2487 "outputs": [],
2488 "source": [
2489 "w_enigma.set_wheels('j', 'e', 'u')\n",
2490 "\n",
2491 "w_enigma.advance()\n",
2492 "assert(w_enigma.wheel_positions == (4, 11, 24))\n",
2493 "assert(cat(w_enigma.wheel_positions_l) == 'jev')\n",
2494 "assert(w_enigma.notch_positions == ([19], [5], [0]))\n",
2495 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'mvqjlyowkdieasgzcunxrbhtfp')\n",
2496 "\n",
2497 "w_enigma.advance()\n",
2498 "assert(w_enigma.wheel_positions == (4, 12, 25))\n",
2499 "assert(cat(w_enigma.wheel_positions_l) == 'jfw')\n",
2500 "assert(w_enigma.notch_positions == ([19], [6], [1]))\n",
2501 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'sjolzuyvrbwdpxcmtiaqfhknge')\n",
2502 "\n",
2503 "w_enigma.advance()\n",
2504 "assert(w_enigma.wheel_positions == (4, 12, 0))\n",
2505 "assert(cat(w_enigma.wheel_positions_l) == 'jfx')\n",
2506 "assert(w_enigma.notch_positions == ([19], [6], [2]))\n",
2507 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'qrxedkoywufmlvgsabpzjnicht')\n",
2508 "\n",
2509 "w_enigma.advance()\n",
2510 "assert(w_enigma.wheel_positions == (4, 12, 1))\n",
2511 "assert(cat(w_enigma.wheel_positions_l) == 'jfy')\n",
2512 "assert(w_enigma.notch_positions == ([19], [6], [3]))\n",
2513 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'hpsukliagqefwvtbjxcodnmrzy')\n",
2514 "\n",
2515 "w_enigma.advance()\n",
2516 "assert(w_enigma.wheel_positions == (4, 12, 2))\n",
2517 "assert(cat(w_enigma.wheel_positions_l) == 'jfz')\n",
2518 "assert(w_enigma.notch_positions == ([19], [6], [4]))\n",
2519 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'zevnbpyqowrtxdifhkulscjmga')\n"
2520 ]
2521 },
2522 {
2523 "cell_type": "code",
2524 "execution_count": 190,
2525 "metadata": {
2526 "collapsed": true
2527 },
2528 "outputs": [],
2529 "source": [
2530 "w_enigma.set_wheels('i', 'd', 'z')\n",
2531 "\n",
2532 "w_enigma.advance()\n",
2533 "assert(w_enigma.wheel_positions == (3, 10, 3))\n",
2534 "assert(cat(w_enigma.wheel_positions_l) == 'ida')\n",
2535 "assert(w_enigma.notch_positions == ([18], [4], [5]))\n",
2536 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'ikhpqrvcambzjondefwyxgsutl')\n",
2537 "\n",
2538 "w_enigma.advance()\n",
2539 "assert(w_enigma.wheel_positions == (3, 10, 4))\n",
2540 "assert(cat(w_enigma.wheel_positions_l) == 'idb')\n",
2541 "assert(w_enigma.notch_positions == ([18], [4], [6]))\n",
2542 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'cdabskhgzwfmlqvunyexpojtri')\n",
2543 "\n",
2544 "w_enigma.advance()\n",
2545 "assert(w_enigma.wheel_positions == (3, 10, 5))\n",
2546 "assert(cat(w_enigma.wheel_positions_l) == 'idc')\n",
2547 "assert(w_enigma.notch_positions == ([18], [4], [7]))\n",
2548 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'pcbwiqhgemyvjsuaftnroldzkx')\n",
2549 "\n",
2550 "w_enigma.advance()\n",
2551 "assert(w_enigma.wheel_positions == (3, 10, 6))\n",
2552 "assert(cat(w_enigma.wheel_positions_l) == 'idd')\n",
2553 "assert(w_enigma.notch_positions == ([18], [4], [8]))\n",
2554 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'xcbfvdnouptmlghjzwykierasq')\n",
2555 "\n",
2556 "w_enigma.advance()\n",
2557 "assert(w_enigma.wheel_positions == (3, 10, 7))\n",
2558 "assert(cat(w_enigma.wheel_positions_l) == 'ide')\n",
2559 "assert(w_enigma.notch_positions == ([18], [4], [9]))\n",
2560 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'xfvglbdynuseriwqpmkzjcoaht')\n",
2561 "\n",
2562 "w_enigma.advance()\n",
2563 "assert(w_enigma.wheel_positions == (3, 10, 8))\n",
2564 "assert(cat(w_enigma.wheel_positions_l) == 'idf')\n",
2565 "assert(w_enigma.notch_positions == ([18], [4], [10]))\n",
2566 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'tfpqlbouynsewjgcdxkahzmriv')\n",
2567 "\n",
2568 "w_enigma.advance()\n",
2569 "assert(w_enigma.wheel_positions == (3, 10, 9))\n",
2570 "assert(cat(w_enigma.wheel_positions_l) == 'idg')\n",
2571 "assert(w_enigma.notch_positions == ([18], [4], [11]))\n",
2572 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'cjaunvlwtbygzexrspqidfhokm')\n",
2573 "\n",
2574 "w_enigma.advance()\n",
2575 "assert(w_enigma.wheel_positions == (3, 10, 10))\n",
2576 "assert(cat(w_enigma.wheel_positions_l) == 'idh')\n",
2577 "assert(w_enigma.notch_positions == ([18], [4], [12]))\n",
2578 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'yltxkrqvowebzpingfucshjdam')\n",
2579 "\n",
2580 "w_enigma.advance()\n",
2581 "assert(w_enigma.wheel_positions == (3, 10, 11))\n",
2582 "assert(cat(w_enigma.wheel_positions_l) == 'idi')\n",
2583 "assert(w_enigma.notch_positions == ([18], [4], [13]))\n",
2584 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'myktluzrnxceaiqsohpdfwvjbg')\n",
2585 "\n",
2586 "w_enigma.advance()\n",
2587 "assert(w_enigma.wheel_positions == (3, 10, 12))\n",
2588 "assert(cat(w_enigma.wheel_positions_l) == 'idj')\n",
2589 "assert(w_enigma.notch_positions == ([18], [4], [14]))\n",
2590 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'pynjrmiugdqxfcvakewzhoslbt')\n",
2591 "\n",
2592 "w_enigma.advance()\n",
2593 "assert(w_enigma.wheel_positions == (3, 10, 13))\n",
2594 "assert(cat(w_enigma.wheel_positions_l) == 'idk')\n",
2595 "assert(w_enigma.notch_positions == ([18], [4], [15]))\n",
2596 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'mwvedyplnoxhaijgrqtszcbkfu')\n",
2597 "\n",
2598 "w_enigma.advance()\n",
2599 "assert(w_enigma.wheel_positions == (3, 10, 14))\n",
2600 "assert(cat(w_enigma.wheel_positions_l) == 'idl')\n",
2601 "assert(w_enigma.notch_positions == ([18], [4], [16]))\n",
2602 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'qcbrfeutvoxpnmjladzhgiykws')\n",
2603 "\n",
2604 "w_enigma.advance()\n",
2605 "assert(w_enigma.wheel_positions == (3, 10, 15))\n",
2606 "assert(cat(w_enigma.wheel_positions_l) == 'idm')\n",
2607 "assert(w_enigma.notch_positions == ([18], [4], [17]))\n",
2608 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'dnoahryetsmukbcvwfjilpqzgx')\n",
2609 "\n",
2610 "w_enigma.advance()\n",
2611 "assert(w_enigma.wheel_positions == (3, 10, 16))\n",
2612 "assert(cat(w_enigma.wheel_positions_l) == 'idn')\n",
2613 "assert(w_enigma.notch_positions == ([18], [4], [18]))\n",
2614 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'nidcfehgbqsovalyjzkxwmutpr')\n",
2615 "\n",
2616 "w_enigma.advance()\n",
2617 "assert(w_enigma.wheel_positions == (3, 10, 17))\n",
2618 "assert(cat(w_enigma.wheel_positions_l) == 'ido')\n",
2619 "assert(w_enigma.notch_positions == ([18], [4], [19]))\n",
2620 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'joifxdulcarhzpbntkwqgysevm')\n",
2621 "\n",
2622 "w_enigma.advance()\n",
2623 "assert(w_enigma.wheel_positions == (3, 10, 18))\n",
2624 "assert(cat(w_enigma.wheel_positions_l) == 'idp')\n",
2625 "assert(w_enigma.notch_positions == ([18], [4], [20]))\n",
2626 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'ptnlsxvozmwdjchayuebrgkfqi')\n",
2627 "\n",
2628 "w_enigma.advance()\n",
2629 "assert(w_enigma.wheel_positions == (3, 10, 19))\n",
2630 "assert(cat(w_enigma.wheel_positions_l) == 'idq')\n",
2631 "assert(w_enigma.notch_positions == ([18], [4], [21]))\n",
2632 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'slwopzqnmxybihdeguavrtcjkf')\n",
2633 "\n",
2634 "w_enigma.advance()\n",
2635 "assert(w_enigma.wheel_positions == (3, 10, 20))\n",
2636 "assert(cat(w_enigma.wheel_positions_l) == 'idr')\n",
2637 "assert(w_enigma.notch_positions == ([18], [4], [22]))\n",
2638 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'hcbedwlamzogixkytsrqvufnpj')\n",
2639 "\n",
2640 "w_enigma.advance()\n",
2641 "assert(w_enigma.wheel_positions == (3, 10, 21))\n",
2642 "assert(cat(w_enigma.wheel_positions_l) == 'ids')\n",
2643 "assert(w_enigma.notch_positions == ([18], [4], [23]))\n",
2644 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'odxbjwzrmelkisavuhnyqpfctg')\n",
2645 "\n",
2646 "w_enigma.advance()\n",
2647 "assert(w_enigma.wheel_positions == (3, 10, 22))\n",
2648 "assert(cat(w_enigma.wheel_positions_l) == 'idt')\n",
2649 "assert(w_enigma.notch_positions == ([18], [4], [24]))\n",
2650 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'udgbfeclrwnhxksvtioqapjmzy')\n",
2651 "\n",
2652 "w_enigma.advance()\n",
2653 "assert(w_enigma.wheel_positions == (3, 10, 23))\n",
2654 "assert(cat(w_enigma.wheel_positions_l) == 'idu')\n",
2655 "assert(w_enigma.notch_positions == ([18], [4], [25]))\n",
2656 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'nrdczqxmowvshaiufblypkjgte')\n",
2657 "\n",
2658 "w_enigma.advance()\n",
2659 "assert(w_enigma.wheel_positions == (3, 10, 24))\n",
2660 "assert(cat(w_enigma.wheel_positions_l) == 'idv')\n",
2661 "assert(w_enigma.notch_positions == ([18], [4], [0]))\n",
2662 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'hkifjdoacebqtzgulyvmpsxwrn')\n",
2663 "\n",
2664 "w_enigma.advance()\n",
2665 "assert(w_enigma.wheel_positions == (3, 11, 25))\n",
2666 "assert(cat(w_enigma.wheel_positions_l) == 'iew')\n",
2667 "assert(w_enigma.notch_positions == ([18], [5], [1]))\n",
2668 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'yptzuhofqvnmlkgbixwcejsrad')\n",
2669 "\n",
2670 "w_enigma.advance()\n",
2671 "assert(w_enigma.wheel_positions == (3, 11, 0))\n",
2672 "assert(cat(w_enigma.wheel_positions_l) == 'iex')\n",
2673 "assert(w_enigma.notch_positions == ([18], [5], [2]))\n",
2674 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'vkdcwhqfjibzsptngumoraeyxl')\n",
2675 "\n",
2676 "w_enigma.advance()\n",
2677 "assert(w_enigma.wheel_positions == (3, 11, 1))\n",
2678 "assert(cat(w_enigma.wheel_positions_l) == 'iey')\n",
2679 "assert(w_enigma.notch_positions == ([18], [5], [3]))\n",
2680 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'wenpbqrouxlkychdfgzvitajms')\n"
2681 ]
2682 },
2683 {
2684 "cell_type": "code",
2685 "execution_count": 191,
2686 "metadata": {},
2687 "outputs": [
2688 {
2689 "data": {
2690 "text/plain": [
2691 "([18], [5], [3])"
2692 ]
2693 },
2694 "execution_count": 191,
2695 "metadata": {},
2696 "output_type": "execute_result"
2697 }
2698 ],
2699 "source": [
2700 "w_enigma.notch_positions"
2701 ]
2702 },
2703 {
2704 "cell_type": "code",
2705 "execution_count": 192,
2706 "metadata": {},
2707 "outputs": [
2708 {
2709 "data": {
2710 "text/plain": [
2711 "('verylongtestmessagewithanextrabitofmessageforgoodmeasure',\n",
2712 " (3, 12, 6),\n",
2713 " ('i', 'f', 'd'),\n",
2714 " ([18], [6], [8]),\n",
2715 " 'urygzpdmxtwshqvfnbljaokice')"
2716 ]
2717 },
2718 "execution_count": 192,
2719 "metadata": {},
2720 "output_type": "execute_result"
2721 }
2722 ],
2723 "source": [
2724 "w_enigma.set_wheels('i', 'd', 'z')\n",
2725 "ct = w_enigma.encipher('verylongtestmessagewithanextrabitofmessageforgoodmeasure')\n",
2726 "assert(ct == 'gstsegeqdrthkfwesljjomfvcqwcfspxpfqqmewvddybarzwubxtpejz')\n",
2727 "assert(w_enigma.wheel_positions == (3, 12, 6))\n",
2728 "assert(cat(w_enigma.wheel_positions_l) == 'ifd')\n",
2729 "assert(w_enigma.notch_positions == ([18], [6], [8]))\n",
2730 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'urygzpdmxtwshqvfnbljaokice')\n",
2731 "\n",
2732 "w_enigma.set_wheels('i', 'd', 'z')\n",
2733 "pt = w_enigma.encipher('gstsegeqdrthkfwesljjomfvcqwcfspxpfqqmewvddybarzwubxtpejz')\n",
2734 "assert(pt == 'verylongtestmessagewithanextrabitofmessageforgoodmeasure')\n",
2735 "\n",
2736 "pt, w_enigma.wheel_positions, w_enigma.wheel_positions_l, w_enigma.notch_positions, cat(w_enigma.lookup(l) for l in string.ascii_lowercase)"
2737 ]
2738 },
2739 {
2740 "cell_type": "code",
2741 "execution_count": 193,
2742 "metadata": {},
2743 "outputs": [
2744 {
2745 "name": "stdout",
2746 "output_type": "stream",
2747 "text": [
2748 "w_enigma.advance()\n",
2749 "assert(w_enigma.wheel_positions == (3, 10, 3))\n",
2750 "assert(cat(w_enigma.wheel_positions_l) == 'ida')\n",
2751 "assert(w_enigma.notch_positions == ([18], [4], [5]))\n",
2752 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'ikhpqrvcambzjondefwyxgsutl')\n",
2753 "\n",
2754 "w_enigma.advance()\n",
2755 "assert(w_enigma.wheel_positions == (3, 10, 4))\n",
2756 "assert(cat(w_enigma.wheel_positions_l) == 'idb')\n",
2757 "assert(w_enigma.notch_positions == ([18], [4], [6]))\n",
2758 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'cdabskhgzwfmlqvunyexpojtri')\n",
2759 "\n",
2760 "w_enigma.advance()\n",
2761 "assert(w_enigma.wheel_positions == (3, 10, 5))\n",
2762 "assert(cat(w_enigma.wheel_positions_l) == 'idc')\n",
2763 "assert(w_enigma.notch_positions == ([18], [4], [7]))\n",
2764 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'pcbwiqhgemyvjsuaftnroldzkx')\n",
2765 "\n",
2766 "w_enigma.advance()\n",
2767 "assert(w_enigma.wheel_positions == (3, 10, 6))\n",
2768 "assert(cat(w_enigma.wheel_positions_l) == 'idd')\n",
2769 "assert(w_enigma.notch_positions == ([18], [4], [8]))\n",
2770 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'xcbfvdnouptmlghjzwykierasq')\n",
2771 "\n",
2772 "w_enigma.advance()\n",
2773 "assert(w_enigma.wheel_positions == (3, 10, 7))\n",
2774 "assert(cat(w_enigma.wheel_positions_l) == 'ide')\n",
2775 "assert(w_enigma.notch_positions == ([18], [4], [9]))\n",
2776 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'xfvglbdynuseriwqpmkzjcoaht')\n",
2777 "\n",
2778 "w_enigma.advance()\n",
2779 "assert(w_enigma.wheel_positions == (3, 10, 8))\n",
2780 "assert(cat(w_enigma.wheel_positions_l) == 'idf')\n",
2781 "assert(w_enigma.notch_positions == ([18], [4], [10]))\n",
2782 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'tfpqlbouynsewjgcdxkahzmriv')\n",
2783 "\n",
2784 "w_enigma.advance()\n",
2785 "assert(w_enigma.wheel_positions == (3, 10, 9))\n",
2786 "assert(cat(w_enigma.wheel_positions_l) == 'idg')\n",
2787 "assert(w_enigma.notch_positions == ([18], [4], [11]))\n",
2788 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'cjaunvlwtbygzexrspqidfhokm')\n",
2789 "\n",
2790 "w_enigma.advance()\n",
2791 "assert(w_enigma.wheel_positions == (3, 10, 10))\n",
2792 "assert(cat(w_enigma.wheel_positions_l) == 'idh')\n",
2793 "assert(w_enigma.notch_positions == ([18], [4], [12]))\n",
2794 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'yltxkrqvowebzpingfucshjdam')\n",
2795 "\n",
2796 "w_enigma.advance()\n",
2797 "assert(w_enigma.wheel_positions == (3, 10, 11))\n",
2798 "assert(cat(w_enigma.wheel_positions_l) == 'idi')\n",
2799 "assert(w_enigma.notch_positions == ([18], [4], [13]))\n",
2800 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'myktluzrnxceaiqsohpdfwvjbg')\n",
2801 "\n",
2802 "w_enigma.advance()\n",
2803 "assert(w_enigma.wheel_positions == (3, 10, 12))\n",
2804 "assert(cat(w_enigma.wheel_positions_l) == 'idj')\n",
2805 "assert(w_enigma.notch_positions == ([18], [4], [14]))\n",
2806 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'pynjrmiugdqxfcvakewzhoslbt')\n",
2807 "\n",
2808 "w_enigma.advance()\n",
2809 "assert(w_enigma.wheel_positions == (3, 10, 13))\n",
2810 "assert(cat(w_enigma.wheel_positions_l) == 'idk')\n",
2811 "assert(w_enigma.notch_positions == ([18], [4], [15]))\n",
2812 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'mwvedyplnoxhaijgrqtszcbkfu')\n",
2813 "\n",
2814 "w_enigma.advance()\n",
2815 "assert(w_enigma.wheel_positions == (3, 10, 14))\n",
2816 "assert(cat(w_enigma.wheel_positions_l) == 'idl')\n",
2817 "assert(w_enigma.notch_positions == ([18], [4], [16]))\n",
2818 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'qcbrfeutvoxpnmjladzhgiykws')\n",
2819 "\n",
2820 "w_enigma.advance()\n",
2821 "assert(w_enigma.wheel_positions == (3, 10, 15))\n",
2822 "assert(cat(w_enigma.wheel_positions_l) == 'idm')\n",
2823 "assert(w_enigma.notch_positions == ([18], [4], [17]))\n",
2824 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'dnoahryetsmukbcvwfjilpqzgx')\n",
2825 "\n",
2826 "w_enigma.advance()\n",
2827 "assert(w_enigma.wheel_positions == (3, 10, 16))\n",
2828 "assert(cat(w_enigma.wheel_positions_l) == 'idn')\n",
2829 "assert(w_enigma.notch_positions == ([18], [4], [18]))\n",
2830 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'nidcfehgbqsovalyjzkxwmutpr')\n",
2831 "\n",
2832 "w_enigma.advance()\n",
2833 "assert(w_enigma.wheel_positions == (3, 10, 17))\n",
2834 "assert(cat(w_enigma.wheel_positions_l) == 'ido')\n",
2835 "assert(w_enigma.notch_positions == ([18], [4], [19]))\n",
2836 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'joifxdulcarhzpbntkwqgysevm')\n",
2837 "\n",
2838 "w_enigma.advance()\n",
2839 "assert(w_enigma.wheel_positions == (3, 10, 18))\n",
2840 "assert(cat(w_enigma.wheel_positions_l) == 'idp')\n",
2841 "assert(w_enigma.notch_positions == ([18], [4], [20]))\n",
2842 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'ptnlsxvozmwdjchayuebrgkfqi')\n",
2843 "\n",
2844 "w_enigma.advance()\n",
2845 "assert(w_enigma.wheel_positions == (3, 10, 19))\n",
2846 "assert(cat(w_enigma.wheel_positions_l) == 'idq')\n",
2847 "assert(w_enigma.notch_positions == ([18], [4], [21]))\n",
2848 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'slwopzqnmxybihdeguavrtcjkf')\n",
2849 "\n",
2850 "w_enigma.advance()\n",
2851 "assert(w_enigma.wheel_positions == (3, 10, 20))\n",
2852 "assert(cat(w_enigma.wheel_positions_l) == 'idr')\n",
2853 "assert(w_enigma.notch_positions == ([18], [4], [22]))\n",
2854 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'hcbedwlamzogixkytsrqvufnpj')\n",
2855 "\n",
2856 "w_enigma.advance()\n",
2857 "assert(w_enigma.wheel_positions == (3, 10, 21))\n",
2858 "assert(cat(w_enigma.wheel_positions_l) == 'ids')\n",
2859 "assert(w_enigma.notch_positions == ([18], [4], [23]))\n",
2860 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'odxbjwzrmelkisavuhnyqpfctg')\n",
2861 "\n",
2862 "w_enigma.advance()\n",
2863 "assert(w_enigma.wheel_positions == (3, 10, 22))\n",
2864 "assert(cat(w_enigma.wheel_positions_l) == 'idt')\n",
2865 "assert(w_enigma.notch_positions == ([18], [4], [24]))\n",
2866 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'udgbfeclrwnhxksvtioqapjmzy')\n",
2867 "\n",
2868 "w_enigma.advance()\n",
2869 "assert(w_enigma.wheel_positions == (3, 10, 23))\n",
2870 "assert(cat(w_enigma.wheel_positions_l) == 'idu')\n",
2871 "assert(w_enigma.notch_positions == ([18], [4], [25]))\n",
2872 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'nrdczqxmowvshaiufblypkjgte')\n",
2873 "\n",
2874 "w_enigma.advance()\n",
2875 "assert(w_enigma.wheel_positions == (3, 10, 24))\n",
2876 "assert(cat(w_enigma.wheel_positions_l) == 'idv')\n",
2877 "assert(w_enigma.notch_positions == ([18], [4], [0]))\n",
2878 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'hkifjdoacebqtzgulyvmpsxwrn')\n",
2879 "\n",
2880 "w_enigma.advance()\n",
2881 "assert(w_enigma.wheel_positions == (3, 11, 25))\n",
2882 "assert(cat(w_enigma.wheel_positions_l) == 'iew')\n",
2883 "assert(w_enigma.notch_positions == ([18], [5], [1]))\n",
2884 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'yptzuhofqvnmlkgbixwcejsrad')\n",
2885 "\n",
2886 "w_enigma.advance()\n",
2887 "assert(w_enigma.wheel_positions == (3, 11, 0))\n",
2888 "assert(cat(w_enigma.wheel_positions_l) == 'iex')\n",
2889 "assert(w_enigma.notch_positions == ([18], [5], [2]))\n",
2890 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'vkdcwhqfjibzsptngumoraeyxl')\n",
2891 "\n",
2892 "w_enigma.advance()\n",
2893 "assert(w_enigma.wheel_positions == (3, 11, 1))\n",
2894 "assert(cat(w_enigma.wheel_positions_l) == 'iey')\n",
2895 "assert(w_enigma.notch_positions == ([18], [5], [3]))\n",
2896 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'wenpbqrouxlkychdfgzvitajms')\n",
2897 "\n",
2898 "w_enigma.advance()\n",
2899 "assert(w_enigma.wheel_positions == (3, 11, 2))\n",
2900 "assert(cat(w_enigma.wheel_positions_l) == 'iez')\n",
2901 "assert(w_enigma.notch_positions == ([18], [5], [4]))\n",
2902 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'szgyqvclkoihurjwenaxmfptdb')\n",
2903 "\n"
2904 ]
2905 }
2906 ],
2907 "source": [
2908 "w_enigma.set_wheels('i', 'd', 'z')\n",
2909 "\n",
2910 "for i in range(26):\n",
2911 " w_enigma.advance()\n",
2912 " print('w_enigma.advance()')\n",
2913 " print(\"assert(w_enigma.wheel_positions == {})\".format(w_enigma.wheel_positions))\n",
2914 " print(\"assert(cat(w_enigma.wheel_positions_l) == '{}')\".format(cat(w_enigma.wheel_positions_l)))\n",
2915 " print(\"assert(w_enigma.notch_positions == {})\".format(w_enigma.notch_positions))\n",
2916 " print(\"assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(w_enigma.lookup(l) for l in string.ascii_lowercase)))\n",
2917 " print()"
2918 ]
2919 },
2920 {
2921 "cell_type": "code",
2922 "execution_count": 215,
2923 "metadata": {},
2924 "outputs": [
2925 {
2926 "name": "stdout",
2927 "output_type": "stream",
2928 "text": [
2929 "self.assertEqual(self.enigma31.wheel_positions, (21, 5, 22))\n",
2930 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayt')\n",
2931 "self.assertEqual(self.enigma31.notch_positions, ([10], [25], [24]))\n",
2932 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'izhrgtecaslkywvqpdjfxonumb')\n",
2933 "\n",
2934 "self.enigma31.advance()\n",
2935 "self.assertEqual(self.enigma31.wheel_positions, (21, 5, 23))\n",
2936 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayu')\n",
2937 "self.assertEqual(self.enigma31.notch_positions, ([10], [25], [25]))\n",
2938 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'dtoavihgflwjnmcsrqpbzekyxu')\n",
2939 "\n",
2940 "self.enigma31.advance()\n",
2941 "self.assertEqual(self.enigma31.wheel_positions, (21, 5, 24))\n",
2942 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'ayv')\n",
2943 "self.assertEqual(self.enigma31.notch_positions, ([10], [25], [0]))\n",
2944 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'xquhtpsdwkjonmlfbvgecriazy')\n",
2945 "\n",
2946 "self.enigma31.advance()\n",
2947 "self.assertEqual(self.enigma31.wheel_positions, (21, 6, 25))\n",
2948 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'azw')\n",
2949 "self.assertEqual(self.enigma31.notch_positions, ([10], [0], [1]))\n",
2950 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'dofapcluvmngjkbezyxwhitsrq')\n",
2951 "\n",
2952 "self.enigma31.advance()\n",
2953 "self.assertEqual(self.enigma31.wheel_positions, (22, 7, 0))\n",
2954 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bax')\n",
2955 "self.assertEqual(self.enigma31.notch_positions, ([11], [1], [2]))\n",
2956 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'jdlbmswztapcexrkuofiqygnvh')\n",
2957 "\n",
2958 "self.enigma31.advance()\n",
2959 "self.assertEqual(self.enigma31.wheel_positions, (22, 7, 1))\n",
2960 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bay')\n",
2961 "self.assertEqual(self.enigma31.notch_positions, ([11], [1], [3]))\n",
2962 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'iydcnuhgawsoxelztvkqfrjmbp')\n",
2963 "\n"
2964 ]
2965 }
2966 ],
2967 "source": [
2968 "w_enigma.set_wheels('a', 'y', 't')\n",
2969 "\n",
2970 "print(\"self.assertEqual(self.enigma31.wheel_positions, {})\".format(w_enigma.wheel_positions))\n",
2971 "print(\"self.assertEqual(cat(self.enigma31.wheel_positions_l), '{}')\".format(cat(w_enigma.wheel_positions_l)))\n",
2972 "print(\"self.assertEqual(self.enigma31.notch_positions, {})\".format(w_enigma.notch_positions))\n",
2973 "print(\"assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(w_enigma.lookup(l) for l in string.ascii_lowercase)))\n",
2974 "print()\n",
2975 "\n",
2976 "for i in range(5):\n",
2977 " w_enigma.advance()\n",
2978 " print('self.enigma31.advance()')\n",
2979 " print(\"self.assertEqual(self.enigma31.wheel_positions, {})\".format(w_enigma.wheel_positions))\n",
2980 " print(\"self.assertEqual(cat(self.enigma31.wheel_positions_l), '{}')\".format(cat(w_enigma.wheel_positions_l)))\n",
2981 " print(\"self.assertEqual(self.enigma31.notch_positions, {})\".format(w_enigma.notch_positions))\n",
2982 " print(\"assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(w_enigma.lookup(l) for l in string.ascii_lowercase)))\n",
2983 " print()"
2984 ]
2985 },
2986 {
2987 "cell_type": "code",
2988 "execution_count": 216,
2989 "metadata": {},
2990 "outputs": [
2991 {
2992 "name": "stdout",
2993 "output_type": "stream",
2994 "text": [
2995 "self.assertEqual(self.enigma31.wheel_positions, (21, 6, 22))\n",
2996 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'azt')\n",
2997 "self.assertEqual(self.enigma31.notch_positions, ([10], [0], [24]))\n",
2998 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'idjbptqwacsvnmregokfzlhyxu')\n",
2999 "\n",
3000 "self.enigma31.advance()\n",
3001 "self.assertEqual(self.enigma31.wheel_positions, (22, 7, 23))\n",
3002 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bau')\n",
3003 "self.assertEqual(self.enigma31.notch_positions, ([11], [1], [25]))\n",
3004 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'rniszouwcxtvqbfymadkglhjpe')\n",
3005 "\n",
3006 "self.enigma31.advance()\n",
3007 "self.assertEqual(self.enigma31.wheel_positions, (22, 7, 24))\n",
3008 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bav')\n",
3009 "self.assertEqual(self.enigma31.notch_positions, ([11], [1], [0]))\n",
3010 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'qijfsdmkbchugxtwazeolypnvr')\n",
3011 "\n",
3012 "self.enigma31.advance()\n",
3013 "self.assertEqual(self.enigma31.wheel_positions, (22, 8, 25))\n",
3014 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bbw')\n",
3015 "self.assertEqual(self.enigma31.notch_positions, ([11], [2], [1]))\n",
3016 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'xprtlozyskjewqfbncidvumahg')\n",
3017 "\n",
3018 "self.enigma31.advance()\n",
3019 "self.assertEqual(self.enigma31.wheel_positions, (22, 8, 0))\n",
3020 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bbx')\n",
3021 "self.assertEqual(self.enigma31.notch_positions, ([11], [2], [2]))\n",
3022 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'vtfuyczoqxmpkwhlisrbdanjeg')\n",
3023 "\n",
3024 "self.enigma31.advance()\n",
3025 "self.assertEqual(self.enigma31.wheel_positions, (22, 8, 1))\n",
3026 "self.assertEqual(cat(self.enigma31.wheel_positions_l), 'bby')\n",
3027 "self.assertEqual(self.enigma31.notch_positions, ([11], [2], [3]))\n",
3028 "assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == 'tjrhzpqdobwxyuifgcvansklme')\n",
3029 "\n"
3030 ]
3031 }
3032 ],
3033 "source": [
3034 "w_enigma.set_wheels('a', 'z', 't')\n",
3035 "\n",
3036 "print(\"self.assertEqual(self.enigma31.wheel_positions, {})\".format(w_enigma.wheel_positions))\n",
3037 "print(\"self.assertEqual(cat(self.enigma31.wheel_positions_l), '{}')\".format(cat(w_enigma.wheel_positions_l)))\n",
3038 "print(\"self.assertEqual(self.enigma31.notch_positions, {})\".format(w_enigma.notch_positions))\n",
3039 "print(\"assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(w_enigma.lookup(l) for l in string.ascii_lowercase)))\n",
3040 "print()\n",
3041 "\n",
3042 "for i in range(5):\n",
3043 " w_enigma.advance()\n",
3044 " print('self.enigma31.advance()')\n",
3045 " print(\"self.assertEqual(self.enigma31.wheel_positions, {})\".format(w_enigma.wheel_positions))\n",
3046 " print(\"self.assertEqual(cat(self.enigma31.wheel_positions_l), '{}')\".format(cat(w_enigma.wheel_positions_l)))\n",
3047 " print(\"self.assertEqual(self.enigma31.notch_positions, {})\".format(w_enigma.notch_positions))\n",
3048 " print(\"assert(cat(self.enigma31.lookup(l) for l in string.ascii_lowercase) == '{}')\".format(cat(w_enigma.lookup(l) for l in string.ascii_lowercase)))\n",
3049 " print()"
3050 ]
3051 },
3052 {
3053 "cell_type": "code",
3054 "execution_count": 221,
3055 "metadata": {},
3056 "outputs": [],
3057 "source": [
3058 "w_enigma.set_wheels('i', 'z', 'd')\n",
3059 "ct = w_enigma.encipher('verylongtestmessagewithanextrabitofmessageforgoodmeasure')\n",
3060 "assert(ct == 'apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')\n",
3061 "assert(w_enigma.wheel_positions == (4, 9, 10))\n",
3062 "assert(cat(w_enigma.wheel_positions_l) == 'jch')\n",
3063 "assert(w_enigma.notch_positions == ([19], [3], [12]))\n",
3064 "assert(cat(w_enigma.lookup(l) for l in string.ascii_lowercase) == 'mopnigfuesqwadbcktjrhylzvx')\n",
3065 "\n",
3066 "w_enigma.set_wheels('i', 'z', 'd')\n",
3067 "pt = w_enigma.decipher('apocwtjuikurcfivlozvhffkoacxufcekthcvodfqpxdjqyckdozlqki')\n",
3068 "assert(pt == 'verylongtestmessagewithanextrabitofmessageforgoodmeasure')"
3069 ]
3070 },
3071 {
3072 "cell_type": "code",
3073 "execution_count": 218,
3074 "metadata": {},
3075 "outputs": [
3076 {
3077 "data": {
3078 "text/plain": [
3079 "([19], [3], [12])"
3080 ]
3081 },
3082 "execution_count": 218,
3083 "metadata": {},
3084 "output_type": "execute_result"
3085 }
3086 ],
3087 "source": [
3088 "w_enigma.notch_positions"
3089 ]
3090 },
3091 {
3092 "cell_type": "code",
3093 "execution_count": 194,
3094 "metadata": {
3095 "collapsed": true
3096 },
3097 "outputs": [],
3098 "source": [
3099 "# Reflector B\n",
3100 "# Rotors III, I, II with rings 17, 11, 19\n",
3101 "# Plugboard pairs GU FZ BD LK TC PS HV WN JE AM\n",
3102 "\n",
3103 "tbt_enigma = Enigma(reflector_b_spec, \n",
3104 " wheel_iii_spec, wheel_iii_notches,\n",
3105 " wheel_i_spec, wheel_i_notches,\n",
3106 " wheel_ii_spec, wheel_ii_notches,\n",
3107 " 17, 11, 19,\n",
3108 " 'GU FZ BD LK TC PS HV WN JE AM'.lower())"
3109 ]
3110 },
3111 {
3112 "cell_type": "code",
3113 "execution_count": 195,
3114 "metadata": {},
3115 "outputs": [
3116 {
3117 "data": {
3118 "text/plain": [
3119 "'jbvbwwzfslhxnhzzccsngebmrnswgjonwbjnzcfgadeuoyameylmpvny'"
3120 ]
3121 },
3122 "execution_count": 195,
3123 "metadata": {},
3124 "output_type": "execute_result"
3125 }
3126 ],
3127 "source": [
3128 "tbt_enigma.set_wheels('a', 'q', 'v')\n",
3129 "ct = tbt_enigma.encipher('very long test message with an extra bit of message for good measure')\n",
3130 "ct"
3131 ]
3132 },
3133 {
3134 "cell_type": "code",
3135 "execution_count": 196,
3136 "metadata": {},
3137 "outputs": [
3138 {
3139 "data": {
3140 "text/plain": [
3141 "'SLGNC SZXLT KZEBG HSTGY WDMPR'"
3142 ]
3143 },
3144 "execution_count": 196,
3145 "metadata": {},
3146 "output_type": "execute_result"
3147 }
3148 ],
3149 "source": [
3150 "target_ct = 'SLGNC SZXLT KZEBG HSTGY WDMPR'\n",
3151 "target_ct"
3152 ]
3153 },
3154 {
3155 "cell_type": "code",
3156 "execution_count": 197,
3157 "metadata": {},
3158 "outputs": [
3159 {
3160 "data": {
3161 "text/plain": [
3162 "'Theyw erede tecte d byBri tishs hipsi nclud'"
3163 ]
3164 },
3165 "execution_count": 197,
3166 "metadata": {},
3167 "output_type": "execute_result"
3168 }
3169 ],
3170 "source": [
3171 "target_pt = 'Theyw erede tecte d byBri tishs hipsi nclud'\n",
3172 "target_pt"
3173 ]
3174 },
3175 {
3176 "cell_type": "code",
3177 "execution_count": 198,
3178 "metadata": {},
3179 "outputs": [
3180 {
3181 "data": {
3182 "text/plain": [
3183 "(29, 43)"
3184 ]
3185 },
3186 "execution_count": 198,
3187 "metadata": {},
3188 "output_type": "execute_result"
3189 }
3190 ],
3191 "source": [
3192 "len(target_ct), len(target_pt)"
3193 ]
3194 },
3195 {
3196 "cell_type": "code",
3197 "execution_count": 199,
3198 "metadata": {},
3199 "outputs": [
3200 {
3201 "name": "stdout",
3202 "output_type": "stream",
3203 "text": [
3204 "SLGNC SZXLT KZEBG HSTGY WDMPR\n",
3205 "Theyw erede tecte d byBri tishs hipsi nclud\n"
3206 ]
3207 }
3208 ],
3209 "source": [
3210 "print('{}\\n{}'.format(target_ct, target_pt))"
3211 ]
3212 },
3213 {
3214 "cell_type": "code",
3215 "execution_count": 200,
3216 "metadata": {},
3217 "outputs": [
3218 {
3219 "name": "stdout",
3220 "output_type": "stream",
3221 "text": [
3222 "Theyw erede tecte d byBri tishs hipsi nclud\n",
3223 "SLGNC SZXLT KZEBG HSTGY WDMPR\n",
3224 "slgncszxltkzebghstgywdmprucuzqdqzpve\n",
3225 "theyweredetectedbybritish\n"
3226 ]
3227 }
3228 ],
3229 "source": [
3230 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3231 "this_pt = tbt_enigma.encipher(target_ct)\n",
3232 "\n",
3233 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3234 "this_ct = tbt_enigma.encipher(target_pt)\n",
3235 "\n",
3236 "\n",
3237 "print('{}\\n{}\\n{}\\n{}'.format(target_pt, target_ct, this_ct, this_pt))"
3238 ]
3239 },
3240 {
3241 "cell_type": "code",
3242 "execution_count": 201,
3243 "metadata": {
3244 "collapsed": true
3245 },
3246 "outputs": [],
3247 "source": [
3248 "import itertools"
3249 ]
3250 },
3251 {
3252 "cell_type": "code",
3253 "execution_count": 202,
3254 "metadata": {
3255 "collapsed": true
3256 },
3257 "outputs": [],
3258 "source": [
3259 "def str_ham(s1, s2):\n",
3260 " \"\"\"Hamming distance for strings\"\"\"\n",
3261 " return sum(1 for c1, c2 in zip(s1, s2) if c1 != c2)"
3262 ]
3263 },
3264 {
3265 "cell_type": "code",
3266 "execution_count": 203,
3267 "metadata": {},
3268 "outputs": [
3269 {
3270 "data": {
3271 "text/plain": [
3272 "0"
3273 ]
3274 },
3275 "execution_count": 203,
3276 "metadata": {},
3277 "output_type": "execute_result"
3278 }
3279 ],
3280 "source": [
3281 "str_ham('hello', 'hello')"
3282 ]
3283 },
3284 {
3285 "cell_type": "markdown",
3286 "metadata": {},
3287 "source": [
3288 "A brute-force check of all message settings, looking for the one that generates the target text."
3289 ]
3290 },
3291 {
3292 "cell_type": "code",
3293 "execution_count": 204,
3294 "metadata": {},
3295 "outputs": [
3296 {
3297 "name": "stdout",
3298 "output_type": "stream",
3299 "text": [
3300 "best ('a', 'a', 'a') 29\n",
3301 "best ('a', 'a', 'a') 29\n",
3302 "best ('a', 'a', 'a') 29\n",
3303 "best ('a', 'a', 'a') 29\n",
3304 "1 loop, best of 3: 20.6 s per loop\n"
3305 ]
3306 }
3307 ],
3308 "source": [
3309 "%%timeit\n",
3310 "best = ('a', 'a', 'a')\n",
3311 "best_hd = 10000\n",
3312 "for w1, w2, w3 in itertools.product(string.ascii_lowercase, repeat=3):\n",
3313 " tbt_enigma.set_wheels(w1, w2, w3)\n",
3314 " this_ct = tbt_enigma.encipher(target_pt)\n",
3315 " if this_ct == target_ct:\n",
3316 " print(w1, w2, w3)\n",
3317 " if str_ham(this_ct, target_ct) < best_hd:\n",
3318 " best = (w1, w2, w3)\n",
3319 " best_hd = str_ham(this_ct, target_ct)\n",
3320 "print('best', best, best_hd)"
3321 ]
3322 },
3323 {
3324 "cell_type": "code",
3325 "execution_count": 205,
3326 "metadata": {},
3327 "outputs": [
3328 {
3329 "name": "stdout",
3330 "output_type": "stream",
3331 "text": [
3332 "Wheels now ['a', 'a', 'b'] enciphering t -> s\n",
3333 "Wheels now ['a', 'a', 'c'] enciphering h -> l\n",
3334 "Wheels now ['a', 'a', 'd'] enciphering e -> g\n",
3335 "Wheels now ['a', 'a', 'e'] enciphering y -> n\n",
3336 "Wheels now ['a', 'b', 'f'] enciphering w -> c\n",
3337 "Wheels now ['a', 'b', 'g'] enciphering e -> s\n",
3338 "Wheels now ['a', 'b', 'h'] enciphering r -> z\n",
3339 "Wheels now ['a', 'b', 'i'] enciphering e -> x\n",
3340 "Wheels now ['a', 'b', 'j'] enciphering d -> l\n",
3341 "Wheels now ['a', 'b', 'k'] enciphering e -> t\n",
3342 "Wheels now ['a', 'b', 'l'] enciphering t -> k\n",
3343 "Wheels now ['a', 'b', 'm'] enciphering e -> z\n",
3344 "Wheels now ['a', 'b', 'n'] enciphering c -> e\n",
3345 "Wheels now ['a', 'b', 'o'] enciphering t -> b\n",
3346 "Wheels now ['a', 'b', 'p'] enciphering e -> g\n",
3347 "Wheels now ['a', 'b', 'q'] enciphering d -> h\n",
3348 "Wheels now ['a', 'b', 'r'] enciphering b -> s\n",
3349 "Wheels now ['a', 'b', 's'] enciphering y -> t\n",
3350 "Wheels now ['a', 'b', 't'] enciphering b -> g\n",
3351 "Wheels now ['a', 'b', 'u'] enciphering r -> y\n",
3352 "Wheels now ['a', 'b', 'v'] enciphering i -> w\n",
3353 "Wheels now ['a', 'b', 'w'] enciphering t -> d\n",
3354 "Wheels now ['a', 'b', 'x'] enciphering i -> m\n",
3355 "Wheels now ['a', 'b', 'y'] enciphering s -> p\n",
3356 "Wheels now ['a', 'b', 'z'] enciphering h -> r\n",
3357 "Wheels now ['a', 'b', 'a'] enciphering s -> u\n",
3358 "Wheels now ['a', 'b', 'b'] enciphering h -> c\n",
3359 "Wheels now ['a', 'b', 'c'] enciphering i -> u\n",
3360 "Wheels now ['a', 'b', 'd'] enciphering p -> z\n",
3361 "Wheels now ['a', 'b', 'e'] enciphering s -> q\n",
3362 "Wheels now ['a', 'c', 'f'] enciphering i -> d\n",
3363 "Wheels now ['a', 'c', 'g'] enciphering n -> q\n",
3364 "Wheels now ['a', 'c', 'h'] enciphering c -> z\n",
3365 "Wheels now ['a', 'c', 'i'] enciphering l -> p\n",
3366 "Wheels now ['a', 'c', 'j'] enciphering u -> v\n",
3367 "Wheels now ['a', 'c', 'k'] enciphering d -> e\n"
3368 ]
3369 },
3370 {
3371 "data": {
3372 "text/plain": [
3373 "('slgncszxltkzebghstgywdmprucuzqdqzpve', 'SLGNC SZXLT KZEBG HSTGY WDMPR')"
3374 ]
3375 },
3376 "execution_count": 205,
3377 "metadata": {},
3378 "output_type": "execute_result"
3379 }
3380 ],
3381 "source": [
3382 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3383 "tbt_enigma.encipher(target_pt, debug=True), target_ct"
3384 ]
3385 },
3386 {
3387 "cell_type": "code",
3388 "execution_count": 206,
3389 "metadata": {},
3390 "outputs": [
3391 {
3392 "name": "stdout",
3393 "output_type": "stream",
3394 "text": [
3395 "Wheels now ['a', 'a', 'b'] enciphering s -> t\n",
3396 "Wheels now ['a', 'a', 'c'] enciphering l -> h\n",
3397 "Wheels now ['a', 'a', 'd'] enciphering g -> e\n",
3398 "Wheels now ['a', 'a', 'e'] enciphering n -> y\n",
3399 "Wheels now ['a', 'b', 'f'] enciphering c -> w\n",
3400 "Wheels now ['a', 'b', 'g'] enciphering s -> e\n",
3401 "Wheels now ['a', 'b', 'h'] enciphering z -> r\n",
3402 "Wheels now ['a', 'b', 'i'] enciphering x -> e\n",
3403 "Wheels now ['a', 'b', 'j'] enciphering l -> d\n",
3404 "Wheels now ['a', 'b', 'k'] enciphering t -> e\n",
3405 "Wheels now ['a', 'b', 'l'] enciphering k -> t\n",
3406 "Wheels now ['a', 'b', 'm'] enciphering z -> e\n",
3407 "Wheels now ['a', 'b', 'n'] enciphering e -> c\n",
3408 "Wheels now ['a', 'b', 'o'] enciphering b -> t\n",
3409 "Wheels now ['a', 'b', 'p'] enciphering g -> e\n",
3410 "Wheels now ['a', 'b', 'q'] enciphering h -> d\n",
3411 "Wheels now ['a', 'b', 'r'] enciphering s -> b\n",
3412 "Wheels now ['a', 'b', 's'] enciphering t -> y\n",
3413 "Wheels now ['a', 'b', 't'] enciphering g -> b\n",
3414 "Wheels now ['a', 'b', 'u'] enciphering y -> r\n",
3415 "Wheels now ['a', 'b', 'v'] enciphering w -> i\n",
3416 "Wheels now ['a', 'b', 'w'] enciphering d -> t\n",
3417 "Wheels now ['a', 'b', 'x'] enciphering m -> i\n",
3418 "Wheels now ['a', 'b', 'y'] enciphering p -> s\n",
3419 "Wheels now ['a', 'b', 'z'] enciphering r -> h\n"
3420 ]
3421 },
3422 {
3423 "data": {
3424 "text/plain": [
3425 "('theyweredetectedbybritish', 'Theyw erede tecte d byBri tishs hipsi nclud')"
3426 ]
3427 },
3428 "execution_count": 206,
3429 "metadata": {},
3430 "output_type": "execute_result"
3431 }
3432 ],
3433 "source": [
3434 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3435 "tbt_enigma.encipher(target_ct, debug=True), target_pt"
3436 ]
3437 },
3438 {
3439 "cell_type": "code",
3440 "execution_count": 207,
3441 "metadata": {},
3442 "outputs": [
3443 {
3444 "data": {
3445 "text/plain": [
3446 "('theyweredetectedbybritish', 'Theyw erede tecte d byBri tishs hipsi nclud')"
3447 ]
3448 },
3449 "execution_count": 207,
3450 "metadata": {},
3451 "output_type": "execute_result"
3452 }
3453 ],
3454 "source": [
3455 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3456 "tbt_enigma.encipher(target_ct), target_pt"
3457 ]
3458 },
3459 {
3460 "cell_type": "code",
3461 "execution_count": 208,
3462 "metadata": {},
3463 "outputs": [
3464 {
3465 "data": {
3466 "text/plain": [
3467 "'mdtbjzuvielkawosqrpcghnxyf'"
3468 ]
3469 },
3470 "execution_count": 208,
3471 "metadata": {},
3472 "output_type": "execute_result"
3473 }
3474 ],
3475 "source": [
3476 "cat(tbt_enigma.plugboard.forward(l) for l in string.ascii_lowercase)"
3477 ]
3478 },
3479 {
3480 "cell_type": "code",
3481 "execution_count": 209,
3482 "metadata": {},
3483 "outputs": [
3484 {
3485 "data": {
3486 "text/plain": [
3487 "10"
3488 ]
3489 },
3490 "execution_count": 209,
3491 "metadata": {},
3492 "output_type": "execute_result"
3493 }
3494 ],
3495 "source": [
3496 "tbt_enigma.set_wheels('a', 'a', 'a')\n",
3497 "tbt_enigma.left_wheel.position"
3498 ]
3499 },
3500 {
3501 "cell_type": "code",
3502 "execution_count": null,
3503 "metadata": {
3504 "collapsed": true
3505 },
3506 "outputs": [],
3507 "source": []
3508 }
3509 ],
3510 "metadata": {
3511 "kernelspec": {
3512 "display_name": "Python 3",
3513 "language": "python",
3514 "name": "python3"
3515 },
3516 "language_info": {
3517 "codemirror_mode": {
3518 "name": "ipython",
3519 "version": 3
3520 },
3521 "file_extension": ".py",
3522 "mimetype": "text/x-python",
3523 "name": "python",
3524 "nbconvert_exporter": "python",
3525 "pygments_lexer": "ipython3",
3526 "version": "3.5.3"
3527 }
3528 },
3529 "nbformat": 4,
3530 "nbformat_minor": 1
3531 }