# Enigma Machine

The Enigma machine, created by the German inventor Arthur Scherbius, was used as Germany's system of encryption before and during World War II. This worksheet emulates a version of the Enigma machine.

Original Author: Abdulaziz Alfoudari

### Code

`Visit us at: http://www.vbparadise.com`

`The Enigma Machine`

`Introduction The Enigma machine, created by the German inventor Arthur Scherbius, was used as Germany's system of encryption before and during World War II. This worksheet emulates a version of the Enigma machine. The three main components of the Enigma machine were a plugboard, three scramblers, and a reflector. The plugboard was used to swap six pairs of letters before they entered the guts of the machine. For example, if I swapped letters 'a' and 'b', and then typed in the letter 'b', it would follow the encryption path originally associated with the letter 'a'. The scrambler, a thick rubber disk filled with wires, was the most important part of the machine. Each scrambler was essentially a monoalphabetic cipher, which encrypted one plaintext letter to a ciphertext letter. Each letter that was typed into the keyboard of the Enigma, passed through three scramblers, so was encrypted three times. The most important feature of the scramblers was that after each letter was encrypted, they would change their orientation to create a new cipher in the following manner. The first scrambler would rotate 1/26 of a revolution, and after one whole revolution, it would turn the second scrambler 1/26 of a revolution. After one whole revolution of the second scrambler, it would eventually turn the third scrambler one notch. This is a similar to a car odometer, the rotor representing single km has to rotates once completely before the rotor representing 10's of km rotates by one unit. Because of this rotation of three scramblers, the cipher text obtained after typing in the same letter consecutively would only repeat itself after the 17,576th letter. The last part of the Enigma machine was the reflector, which was a little bit like the scramblers, but it did not rotate, and the wires entered and exited through the same side. So if a letter 'a' goes into the reflector, it might come out as a letter 's', and then get sent back through the three scramblers in reverse order, through the plugboard, and finally show up as the encrypted letter. The reflector allows users to use the Enigma in the same way for both encrypting and decrypting messages. Because of the changing nature of the machine, sender and receiver must agree on a set of keys, or initial conditions, before communicating with the Enigma. On the actual Enigma machine, the three scramblers could be interchanged, meaning that there were 6 different orders that they could be positioned in. (123, 132, 213, 231, 312, 321) Also, each scrambler could be rotated to any one of 26 initial orientations, yielding 26*26*26 = 17,576 different settings. Also the number of ways of swapping six pairs of letters out of 26 is 100,391,791,500! So the total number of keys available is 6*17,576*100,391,791,500 = 10,586,916,764,424,000!!Code> restart; `

`Given a seed, this will create a scrambler with random internal wiring. `

`> makeScrambler := proc(seed)local numGen, i, j, num, scrambler;scrambler := [];randomize(seed);numGen := rand(1..26);for i from 1 to 26 donum := numGen();for j while member(num, scrambler) donum := numGen();end do;scrambler := [op(scrambler),num];end do;end proc: Given a seed, this will create a reflector with random internal wiring. > makeReflector := proc(seed)local num, pos, i, j, reflector, numGen, temp;reflector := table();randomize(seed);numGen := rand(1..26);temp := [ entries(reflector) ];for i while nops(temp) <> 26 dopos := numGen();for j while member([pos],temp) dopos := numGen();end do;num := numGen();for j while member([num],temp) or num = pos donum := numGen();end do;reflector[pos] := num;reflector[num] := pos;temp := [ entries(reflector) ]; end do;for i from 1 to 26 dotemp[i] := temp[i][1];end do;temp;end proc: `

`This will rotate a scrambler passed in by list, by making the n'th letter in the list the first letter. `

`Ex: list := [1, 2, 3, 4, 5]; list := rotate(list, 3); list; [3, 4, 5, 1, 2] > rotate := proc(list, n)local i, toReturn, rotateBy;toReturn := [];rotateBy := n - 1;for i from 1 to 26 dorotateBy := rotateBy + 1;toReturn := [op(toReturn),list[((rotateBy - 1)mod 26) + 1]];end do;end proc: `

`This will create three scramblers, position them in the order given by scramOrder, arrange them according to orientation, and create a plugboard according to plugSettings. It will then encrypt or decrypt (the processes are the same) message and return the result. `

`> enigma := proc(message, scramOrder, orientation, plugSettings)local i, scramblers, scram1, scram2, scram3, letter1, letter2, letter3, plainText,pair1, pair2, pair3, pair4, pair5, pair6, plugboard, reflector, cipherText, toReturn,plugIndex, plugEntry;plainText := StringTools[LowerCase](message);plainText := convert(plainText, bytes);scramblers := [ makeScrambler(456), makeScrambler(504), makeScrambler(607) ];scram1 := scramblers[scramOrder[1]];scram2 := scramblers[scramOrder[2]];scram3 := scramblers[scramOrder[3]];letter1 := convert(StringTools[LowerCase](orientation[1]),bytes)[1] - 96;letter2 := convert(StringTools[LowerCase](orientation[2]),bytes)[1] - 96;letter3 := convert(StringTools[LowerCase](orientation[3]),bytes)[1] - 96;scram1 := rotate(scram1, letter1);scram2 := rotate(scram2, letter2);scram3 := rotate(scram3, letter3);pair1 := convert(StringTools[LowerCase](plugSettings[1]),bytes);pair2 := convert(StringTools[LowerCase](plugSettings[2]),bytes);pair3 := convert(StringTools[LowerCase](plugSettings[3]),bytes);pair4 := convert(StringTools[LowerCase](plugSettings[4]),bytes);pair5 := convert(StringTools[LowerCase](plugSettings[5]),bytes);pair6 := convert(StringTools[LowerCase](plugSettings[6]),bytes);plugboard := table([(pair1[1] - 96) = pair1[2] - 96, (pair2[1] - 96) = pair2[2] - 96,(pair3[1] - 96) = pair3[2] - 96, (pair4[1] - 96) = pair4[2] - 96,(pair5[1] - 96) = pair5[2] - 96, (pair6[1] - 96) = pair6[2] - 96]);plugIndex := [indices(plugboard)];plugEntry := [entries(plugboard)];for i from 1 to 6 doplugIndex[i] := plugIndex[i][1];plugEntry[i] := plugEntry[i][1];end do; reflector := makeReflector(978);cipherText := encode(plainText, plugIndex, plugEntry, scram1, scram2, scram3, reflector);toReturn := convert(cipherText, bytes);end proc: > encode := proc(plainText, plugIndex, plugEntry, scrm1, scrm2, scrm3, reflector)local i, scram1, scram2, scram3, pos1, pos2, pos3, letter, response;scram1 := scrm1; scram2 := scrm2; scram3 := scrm3;pos1 := 1; pos2 := 1; pos3 := 1;response := [];for i from 1 to nops(plainText) doletter := plainText[i] - 96;if letter > 0 and letter < 27 thenif member(letter, plugIndex, 'x') thenletter := plugEntry[x];elif member(letter, plugEntry, 'y') thenletter := plugIndex[y];end if;letter := scram1[letter];letter := scram2[letter];letter := scram3[letter];letter := reflector[letter];member(letter, scram3, 'letter');member(letter, scram2, 'letter');member(letter, scram1, 'letter');if member(letter, plugEntry, 'z') thenletter := plugIndex[z];elif member(letter, plugIndex, 'w') thenletter := plugEntry[w];end if;end if;scram1 := rotate(scram1, 2);pos1 := pos1 + 1;if pos1 > 26 thenpos1 := 1;scram2 := rotate(scram2, 2);pos2 := pos2 + 1;if pos2 > 26 thenpos2 := 1;scram3 := rotate(scram3, 2);pos3 := pos3 + 1;if pos3 > 26 thenpos3 := 1;end if;end if;end if;response := [op(response), letter + 96];end do; end proc:  `

`Results > message := "There is one more feature of Scherbius's design, known as the ring, which has not yet been mentioned. Although the ring does have some effect on encryption, it is the least significant part of the whole Enigma machine."; `

`> code := enigma(message, [2,3,1], [c,b,t],[tg,yh,rf,ep,av,bn]);`

`> result := enigma(code, [2,3,1], [c,b,t],[tg,yh,rf,ep,av,bn]);`

` `

`The actual Enigma machine did not have upper and lower case letters, and did not have any spaces or punctuation, so this worksheet will always output lower case letters and ignore spaces and puntuation. If we try to decrypt the message with slightly different initial conditions, the result will be gibberish. `

` `

`> result2 := enigma(code, [2,3,1], [a,b,t], [tg,yh,rf,ep,av,bn]);`

` `

`Note: This article was taken from:Sylvain Muisesmuise@student.math.uwaterloo.ca`

Posted: 2002-06-01
By: ArchiveBot
Viewed: 86 times

Categories

Visual Basic 6

Attachments

No attachments for this post