@ondoher/enigma 0.1.0

package/lib/enigma/Rotor.js

@@ -0,0 +1,170 @@
+import Encoder from "./Encoder.js";
+
+/**
+ * Create an instance of this class to construct a Rotor object. The Rotor class
+ * encapsulates many of the peculiar behaviors of the Enigma. All connector
+ * values here are specified in physical space.
+ */
+export default class Rotor extends Encoder {
+
+/*
+
+- **name**
+- **settings**
+    - _alphabet_ (optional)
+    - _map_
+    - _ringSetting_
+    - _turnovers_
+
+*/
+
+
+
+
+
+	/**
+	 * This is the constructor for the rotor.
+	 *
+	 * @param {String} name the name of the rotor; under normal circumstances
+	 * 	this will be the string 'rotor-' plus the standard name for the rotor,
+	 	* for example 'rotor-IV'
+	 * @param {Object} settings an object that contains the various options that
+	 * define the the rotor and how it is configured.
+	 * @property [alphabet] set this to a string of letters that are an
+	 * alternative to the standard A-Z. Defaults to A-Z
+	 * @property {String} map a string that defines the mapping between the
+	 * input and output connectors. The index into the string is the input
+	 * connector and the value of this string at that index is the output
+	 * connector. For example 'EKMFLGDQVZNTOWYHXUSPAIBRCJ', which is the map
+	 * for standard rotor I.
+	 * @property {Number} [ringSetting] a number that specifies how far forward
+	 * 	to offset the outer ring relative to the internal wiring.
+	 * @property {String} turnovers a string that specifies the relative
+	 * location of where on the rotor turnover will occur. The value here is the
+	 * rotation value would be displayed in the window when turnover happens,
+	 * expressed as a character. The standard rotors VI-VIII, available in the
+	 * later model M3 had two turnover locations, M and Z. Pass an empty string
+	 * when the rotor does not rotate during stepping
+	 */
+	constructor(name, settings) {
+		super(name, settings);
+		var { map, turnovers = '', ringSetting = 0} = settings
+
+		this.map = [...map];
+		this.rightMap = this.makeMap(map);
+		this.leftMap = this.makeReverseMap(this.rightMap);
+		this.length = map.length;
+		this.ringOffset = ringSetting;
+
+		this.turnoverLookup = this.makeMap(turnovers);
+		this.offset = 0;
+		if (turnovers === '') this.fixed = true;
+		this.turnovers = this.turnoverLookup.reduce(function(turnovers, turnover) {
+			turnovers[turnover] = true;
+			return turnovers;
+		}.bind(this), {});
+	}
+
+	/**
+	 * Call this method to select the initial rotation of the rotor. This is a
+	 * letter offset from the logical 0 connector. The initial rotation will
+	 * also take into account the ring setting
+	 *
+	 * @param {String} connector This is a letter value that corresponds to what
+	 * would appear in the rotation window. This value will be adjusted for the
+	 * ring setting.
+	 */
+	setStartPosition(connector) {
+		var pos = this.alphabet.indexOf(connector);
+		this.offset = this.normalize(pos - this.ringOffset);
+	}
+
+	/**
+	 * Call this method to map an input connector to an output connector when
+	 * the signal is moving in the given direction. The input connector
+	 * represents a physical location in real space. To get the logical
+	 * connector for the rotor's zero point we need to adjust the connector
+	 * number for the current rotation.
+	 *
+	 * @param {String} direction either right for moving towards the reflector or
+	 * 	left if moving back
+	 * @param {Number} input the connector in physical space
+	 *
+	 * @returns {Number} the output connector in physical space.
+	 */
+	encode(direction, input) {
+		var map = direction === 'right' ? this.rightMap : this.leftMap;
+		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
+
+		//find the logical position of the input connector in the wiring map
+		var index = this.normalize(input + this.offset);
+
+		// get the logical output connector and convert that to the physical
+		// output connector
+		var output = map[index];
+		var result = this.normalize(output - this.offset);
+
+		this.fire(evName, this.name,
+			`${evName} ${this.name}, input: ${input} ouput: ${result} relative input: ${index}, relative output: ${output} rotation: ${this.offset}`,
+			{
+				input : input,
+				output: result,
+				logicalInput: index,
+				logicalOutput: output,
+				rotation: this.offset,
+			}
+		);
+
+		return result;
+	}
+
+	/**
+	 * Call this method to step the rotor
+	 *
+	 * @returns {Boolean} true true if the next rotor should be stepped
+	 */
+	step() {
+		// Because the turnover notch is attached to the outer ring, and the
+		// logical coordinates is based on the wiring, the logical position of
+		// the notch for turnover needs to be adjusted to remove the ring offset.
+		this.offset = this.normalize(this.offset + 1);
+		var turnoverOffset = this.normalize(this.offset + this.ringOffset);
+
+		// turnover happens when we step past the turnover point
+		var turnover = this.turnovers[this.normalize(turnoverOffset - 1)];
+
+		this.fire('step', this.name,
+			`step ${this.name}, ${this.offset} ${this.normalize(this.offset + this.ringOffset)} ${turnoverOffset} ${Boolean(turnover)}`,
+			{
+				rotation: this.offset,
+				ringSetting: this.ringOffset,
+				turnover: Boolean(turnover),
+			}
+		);
+
+		return turnover;
+	}
+
+	/**
+	 * Call this method to see if the next step on this rotor will lead to
+	 * turnover. The Enigma class will call this on the middle rotor to handle
+	 * double stepping.
+	 *
+	 * @returns true if this rotor will turnover on the next step
+	 */
+	willTurnover() {
+		var turnoverOffset = this.normalize(this.offset + this.ringOffset);
+
+		// double stepping happens when we step to the turnover point
+		return this.turnovers[turnoverOffset];
+	}
+
+	/**
+	 * Call this method to find whether this is a fixed rotor. This is used for
+	 * the non stepping rotors--beta and gamma--that are used in the M4
+	 * @returns
+	 */
+	isFixed() {
+		return this.fixed;
+	}
+}

package/lib/enigma/consts.js

@@ -0,0 +1 @@
+export var STANDARD_ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';

package/lib/enigma/index.js

@@ -0,0 +1,7 @@
+export {default as Enigma} from './Enigma.js';
+export {default as EntryDisc} from './EntryDisk.js';
+export {default as inventory} from './Inventory.js';
+export {default as PlugBoard} from './PlugBoard.js';
+export {default as Reflector} from './Rotor.js';
+
+import './standardInventory.js'

package/lib/enigma/standardInventory.js

@@ -0,0 +1,95 @@
+import inventory from'./Inventory.js';
+
+/**
+ * This module adds all the standard inventory components to simulate models
+ * I, M3 and M4
+ */
+
+export var entryDiscDefintions = {
+	default: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+};
+
+export var rotorDefinitions = {
+	I: {
+		map: 'EKMFLGDQVZNTOWYHXUSPAIBRCJ', //p->q
+		turnovers: 'Q'
+	},
+	II: {
+		map: 'AJDKSIRUXBLHWTMCQGZNPYFVOE', //d->e
+		turnovers: 'E'
+	},
+	III: {
+		map: 'BDFHJLCPRTXVZNYEIWGAKMUSQO', // u->v
+		turnovers: 'V'
+	},
+	IV: {
+		map: 'ESOVPZJAYQUIRHXLNFTGKDCMWB', // i-> j
+		turnovers: 'J'
+	},
+
+	V: {
+		map: 'VZBRGITYUPSDNHLXAWMJQOFECK', //y->z
+		turnovers: 'Z'
+	},
+
+	VI: {
+		map: 'JPGVOUMFYQBENHZRDKASXLICTW', // l->m, y-z
+		turnovers: 'ZM'
+	},
+
+	VII: {
+		map: 'NZJHGRCXMYSWBOUFAIVLPEKQDT', //l-m
+		turnovers: 'ZM'
+	},
+
+	VIII: {
+		map: 'FKQHTLXOCBJSPDZRAMEWNIUYGV',
+		turnovers: 'ZM'
+	},
+
+	Beta: {
+		map: 'LEYJVCNIXWPBQMDRTAKZGFUHOS',
+		turnovers: ''
+	},
+	Gamma: {
+		map: 'FSOKANUERHMBTIYCWLQPZXVGJD',
+		turnovers: ''
+	}
+};
+
+export var reflectorDefinitions = {
+	A: 'EJMZALYXVBWFCRQUONTSPIKHGD',
+	B: 'YRUHQSLDPXNGOKMIEBFZCWVJAT',
+	C: 'FVPJIAOYEDRZXWGCTKUQSBNMHL',
+	'Thin-B': 'ENKQAUYWJICOPBLMDXZVFTHRGS',
+	'Thin-C': 'RDOBJNTKVEHMLFCWZAXGYIPSUQ'
+};
+
+
+function addRotor(name) {
+	inventory.addRotor(name, rotorDefinitions[name].map, rotorDefinitions[name].turnovers);;
+}
+
+function addReflector(name) {
+	inventory.addReflector(name, reflectorDefinitions[name]);
+}
+
+inventory.addEntryDisc('default', entryDiscDefintions.default);
+
+addRotor('I');
+addRotor('II');
+addRotor('III');
+addRotor('IV');
+addRotor('V');
+addRotor('VI');
+addRotor('VII');
+addRotor('VIII');
+
+addRotor('Beta');
+addRotor('Gamma');
+
+addReflector('A');
+addReflector('B');
+addReflector('C');
+addReflector('Thin-B');
+addReflector('Thin-C');

package/lib/enigma/tests/EnigmaData.js

@@ -0,0 +1,236 @@
+export const enigmaData = {
+	sampleFieldMessages: [
+		{
+			source: 'http://wiki.franklinheath.co.uk/index.php/Enigma/Sample_Decrypts#Operation_Barbarossa.2C_1941',
+			model: 'I/M3',
+			setup: {
+				reflector:	'B',
+				rotors:	['II', 'IV', 'V'],
+				ringSettings:  [2, 21, 12],
+				plugs:	'AV BS CG DL FU HZ IN KM OW RX'
+			},
+			message: {
+				key: 'BLA',
+				encoded: 'EDPUDNRGYSZRCXNUYTPOMRMBOFKTBZREZKMLXLVEFGUEYSIOZVEQMIKUBPMMYLKLTTDEISMDICAGYKUACTCDOMOHWXMUUIAUBSTSLRNBZSZWNRFXWFYSSXJZVIJHIDISHPRKLKAYUPADTXQSPINQMATLPIFSVKDASCTACDPBOPVHJK',
+				decoded: 'AUFKLXABTEILUNGXVONXKURTINOWAXKURTINOWAXNORDWESTLXSEBEZXSEBEZXUAFFLIEGERSTRASZERIQTUNGXDUBROWKIXDUBROWKIXOPOTSCHKAXOPOTSCHKAXUMXEINSAQTDREINULLXUHRANGETRETENXANGRIFFXINFXRGTX',
+			}
+		},
+		{
+			source: 'http://wiki.franklinheath.co.uk/index.php/Enigma/Sample_Messages#U-264_.28Kapit.C3.A4nleutnant_Hartwig_Looks.29.2C_1942',
+			model: 'M4',
+			setup: {
+				reflector: 'Thin-B',
+				rotors: ['Beta', 'II', 'IV', 'I'],
+				ringSettings: [1, 1, 1, 22],
+				plugs:	'AT BL DF GJ HM NW OP QY RZ VX',
+			},
+			message: {
+				key: 'VJNA',
+				encoded: 'NCZWVUSXPNYMINHZXMQXSFWXWLKJAHSHNMCOCCAKUQPMKCSMHKSEINJUSBLKIOSXCKUBHMLLXCSJUSRRDVKOHULXWCCBGVLIYXEOAHXRHKKFVDREWEZLXOBAFGYUJQUKGRTVUKAMEURBVEKSUHHVOYHABCJWMAKLFKLMYFVNRIZRVVRTKOFDANJMOLBGFFLEOPRGTFLVRHOWOPBEKVWMUQFMPWPARMFHAGKXIIBG',
+				decoded: 'VONVONJLOOKSJHFFTTTEINSEINSDREIZWOYYQNNSNEUNINHALTXXBEIANGRIFFUNTERWASSERGEDRUECKTYWABOSXLETZTERGEGNERSTANDNULACHTDREINULUHRMARQUANTONJOTANEUNACHTSEYHSDREIYZWOZWONULGRADYACHTSMYSTOSSENACHXEKNSVIERMBFAELLTYNNNNNNOOOVIERYSICHTEINSNULL',
+			}
+		},
+		{
+			source: 'http://wiki.franklinheath.co.uk/index.php/Enigma/Sample_Messages#Scharnhorst_.28Konteradmiral_Erich_Bey.29.2C_1943',
+			model: 'M3',
+			setup: {
+				reflector: 'B',
+				rotors: ['III', 'VI', 'VIII'],
+				ringSettings: [1, 8, 13],
+				plugs: 'AN EZ HK IJ LR MQ OT PV SW UX',
+			},
+			message: {
+				key: 'UZV',
+				encoded: 'YKAENZAPMSCHZBFOCUVMRMDPYCOFHADZIZMEFXTHFLOLPZLFGGBOTGOXGRETDWTJIQHLMXVJWKZUASTR',
+				decoded: 'STEUEREJTANAFJORDJANSTANDORTQUAAACCCVIERNEUNNEUNZWOFAHRTZWONULSMXXSCHARNHORSTHCO',
+			}
+		},
+		{
+			source: 'https://enigma.hoerenberg.com/index.php?cat=The%20U534%20messages&page=P1030662',
+			model: 'M4',
+			setup: {
+				reflector: 'Thin-C',
+				rotors: ['Beta', 'V', 'VI', 'VIII'],
+				ringSettings: 'AAEL',
+				plugs: 'AE BF CM DQ HU JN LX PR SZ VW',
+			},
+			message: {
+				key: 'WIIJ',
+				encoded: 'LIRZMLWRCDMSNKLKBEBHRMFQFEQAZWXBGBIEXJPYFCQAAWSEKDEACOHDZKCZTOVSYHFNSCMAIMIMMAVJNLFXEWNPUIRINOZNCRVDHCGKCYRVUJQPVKEUIVVXGLQMKRJMDMLXLLRLYBKJWRXBQRZWGCCNDOPMGCKJ',
+				decoded: 'UUUVIRSIBENNULEINSYNACHRXUUUSTUETZPUNKTLUEBECKVVVCHEFVIERXUUUFLOTTXXMITUUUVIERSIBENNULZWOUNDUUUVIERSIBENNULDREIZURFLENDERWERFTLUEBECKGEHENXFONDORTFOLGTWEITERESX',
+			}
+		},
+		{
+			source: 'https://enigma.hoerenberg.com/index.php?cat=Norrk%C3%B6ping%20messages&page=PAGE_47_DOEP',
+			model: 'M3',
+			setup: {
+				reflector: 'B',
+				rotors: ['VII', 'IV', 'VI'],
+				ringSettings: 'AGW',
+				plugs: 'BM DX EW GP JO KV NZ RT',
+			},
+			message: {
+				key: 'NSH',
+				encoded: 'YEWZANTGDXWUVDSSYQELAMUOAMBVFZAJWFATABRMMBWXWTLFIOYBTEXXFFAOHADDXWWGBEROYDWLEUTP',
+				decoded: 'KOFFERGRAMOPHONKEINSINNKTZCMYQWPJDZXQLXGJXKWXLQDHYKCMIRBYKFHCMQWHVXLRHGDXMQWCHYK',
+			}
+		},
+		{
+			source: 'https://enigma.hoerenberg.com/index.php?cat=Norrk%C3%B6ping%20messages&page=PAGE_49_KRLR',
+			model: 'M3',
+			setup: {
+				reflector: 'B',
+				rotors: ['VII', 'IV', 'VI'],
+				ringSettings: 'AGW',
+				plugs: 'BM DX EW GP JO KV NZ RT',
+			},
+			message: {
+				key: 'RPR',
+				encoded: 'PBQOMEWLLMJFBXKPZNBHRGLUGVHJBXYPSEACOXOTBQRWVTPVVYHLLDOCQQKIWVAMJNFADSUNAVMJGJIBMUGBWWRKJBZNHVELOGZHTISLTUWS',
+				decoded: 'VERWALTUNGSAMTREICHSGERICHTARBEITSLAGERNICHTAUFSCHLAGENVCNSTDMQWZVGNVMBCPDGKPFQZWTRLDMFNGHSRDTFZGLDKCVLMNHGF',
+
+			}
+
+		}
+	],
+	sampleVerifiedMessages: [
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', ],
+			model: 'I',
+			setup: {
+				rotors: ['II', 'IV', 'III'],
+				plugs: 'IU ZM NK YH SJ DB TX RF OG QE',
+				ringSettings: [22, 26, 26],
+				reflector: 'A'
+			},
+			message: {
+				key: 'ZAE',
+				encoded: 'EICSSVSACTFYCNWRBCXMELAKMTBDSSPAIHMUKGFDPVEUHUDWRKOTITUTNWCEJTGUUGVVBOSVOYIDXHBRFYNOAJWISOZDIOPIXJDJJXBUYJWQRMMACUDGZCVHIFPRPCUDDWTXLCEUEASBRVOUFRTQDDOWWGCIEQSAYEXYHLCJHKWRMNQUHERAEGUXBQQDWIZYQHFJZRBZBNGWPUGLUYMUCXFKPPBWXAPRRXZLWBOFPWQHKVXWKHTNJXQCZZROWMYPLSMJINVBUCIPVYZGZXMONPMEIFWALQFEKJRRJYXVRNUFWNMPMIYBCQCJNSLNHIHOESEVNFMBKPPQTWQXQMCKIMQNPGOOTKNJDBKKHTWDUSJJGTSFJJLQ',
+				decoded: 'HOWOTHERWISETHEKINGSIRHATHLAIDTHATINADOZENPASSESBETWEENYOURSELFANDHIMHESHALLNOTEXCEEDYOUTHREEHITSHEHATHLAIDONTWELVEFORNINEANDITWOULDCOMETOIMMEDIATETRIALIFYOURLORDSHIPWOULDVOUCHSAFETHEANSWERBYTHELORDHORATIOTHESETHREEYEARSIHAVETAKENANOTEOFITTHEAGEISGROWNSOPICKEDTHATTHETOEOFTHEPEASANTCOMESSONEARTHEHEELOFTHECOURTIERHEGAFFSHISKIBETHYSTATEISTHEMOREGRACIOUSFORTISAVICETOKNOWHIM'
+			}
+
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html'],
+			model: 'I',
+			setup: {
+				rotors: ['III', 'IV', 'I'],
+				plugs: 'EL ID YR QP FX HO KJ NS BV WU',
+				ringSettings: [10, 22, 8],
+				reflector: 'B'
+			},
+			message: {
+				key: 'OAK',
+				encoded: 'RXDVNGAFUCJOOJHUZZKLZLCIVQZQUJYGRAQSUQWSWFCGJXGDGWWQMTYTLLLGTLWVCSQQITTKGOEDMERMCMPERRYAZKEDRFSDKWVQUSMGFXLJFOWKIUMTJXKQDBHGPJUKQRTSBTZ',
+				decoded: 'GOODEVENSIRMAYONEBEPARDONDANDRETAINTHEOFFENCEHOWLONGHATHSHEBEENTHUSTHOUGHTANDAFFLICTIONPASSIONHELLITSELFSHETURNSTOFAVOURANDTOPRETTINESS'
+			}
+
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html'],
+			model: 'I',
+			setup: {
+				rotors: ['III', 'I', 'II'],
+				plugs: 'EJ ZX TU KV MI DB NW GQ LR FO',
+				ringSettings: [4, 5, 7],
+				reflector: 'B'
+			},
+			message: {
+				start: 'OEC',
+				encoded: 'WCOJLTOXJZSYRDRGPLWJJOXWFCCISIRBMEHOKYWDFNJFWXCWATBJJTJLTMEQMWBIFXVIBJJOPAYKSUZIFATKZLMMVHNIYOPHBYKBAAHCYPKELSEWGKBHAHROMIGPBRYQXFCRJGUXWHFKBGTECDZDZLWVIHXKOFBXWJKETDLBLWKDTPPFUFKPKMROJHZMDDBHTKXSWMPNRYOVWEEUIMKYBGVSQJCFNBKKLVYZGKQQRTMMPTWJAMJQPGDCGHLUNQKSVWOAALTXS',
+				decoded: 'HOWDANGEROUSISITTHATTHISMANGOESLOOSEYETMUSTNOTWEPUTTHESTRONGLAWONHIMHESLOVEDOFTHEDISTRACTEDMULTITUDEWHOLIKENOTINTHEIRJUDGMENTBUTTHEIREYESANDWHERETISSOTHEOFFENDERSSCOURGEISWEIGHDBUTNEVERTHEOFFENCEAMINOTITHERIGHTOLDJEPHTHAHAHMYGOODLORDWHATHAVEISEENTONIGHTWHATGERTRUDE'
+			}
+
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html'],
+			model: 'M3',
+			setup: {
+				rotors: ['IV', 'VII', 'I'],
+				plugs: 'NI RM AH VQ UL FD GS WY JE TX',
+				ringSettings: [23, 13, 3],
+				reflector: 'B'
+			},
+			message: {
+				start: 'HMP',
+				encoded: 'PDWBCHJGYPCHHUXNDVUGEZSYIUATENCFMYUIQPWIBBIELWXUNAWZNPVNKTBOJTHEDWDJJKQEOEPSMJBRGTWJGNURUXXEFYGJKUSHYPFZIDEWODCRKXFFLQKVLRLXNIACDAZEIFJXTLZXUSJRLQIDBJTIDUAFRJAYTSNFBJBXKVLASUZQMPCJJLCOZDMDIRPEJANYQCIUPLAPSMQMXXXHSMMNEDCSDDILZOWGPXVWKWKHKYLXEOYFHMNBPURLKA',
+				decoded: 'COMEHITHERGENTLEMENANDLAYYOURHANDSAGAINUPONMYSWORDNEVERTOSPEAKOFTHISTHATYOUHAVEHEARDSWEARBYMYSWORDAREYOUFAIRNOMOREBEDONEWESHOULDPROFANETHESERVICEOFTHEDEADTOSINGAREQUIEMANDSUCHRESTTOHERASTOPEACEPARTEDSOULSNIGGARDOFQUESTIONBUTOFOURDEMANDSMOSTFREEINHISREPLY'
+			}
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html'],
+			model: 'M3',
+			setup: {
+				rotors: ['VI', 'IV', 'II'],
+				plugs: 'QZ DK LA MX ET BG VO SH YP WJ',
+				ringSettings: [4, 15, 21],
+				reflector: 'B'
+			},
+			message: {
+				key: 'ASA',
+				encoded: 'URVTSTZATDUFQLGIUJKVRRVJZHSHDOGEKHREOYECTDTBUYZACWNGMHTUGWNUIUJMKHQQAPAKQIQYDHXWBRILLAURPOYTGNYUDANCLJCKSIPCJWLCLBHVXKNNRXPHHJUQJMRBZZASHQLCLQMMTYOA',
+				decoded: 'EXCHANGEFORGIVENESSWITHMENOBLEHAMLETMINEANDMYFATHERSDEATHCOMENOTUPONTHEENORTHINEONMEHORATIOIAMDEADTHOULIVESTREPORTMEANDMYCAUSEARIGHTTOTHEUNSATISFIED'
+			}
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'http://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-u_v26_en.html'],
+			model: 'M3',
+			setup: {
+				rotors: ['II', 'I', 'VII'],
+				plugs: 'BL SK WD FN HZ IX QU EJ PC OM',
+				ringSettings: [19, 20, 14],
+				reflector: 'B'
+			},
+			message: {
+				key: 'HRO',
+				encoded: 'LJVBCURJWLPLFSYKZNBEXTUHTPCWRQTOKBRBCDMAMQCDMIXIOMVCVKBVDXMXIJVELDNRBXPWCCICPEHAXTVZYV',
+				decoded: 'WHYONEFAIRDAUGHTERANDNOMORETHEWHICHHELOVEDPASSINGWELLYOUTOLDUSOFSOMESUITWHATISTLAERTES'
+			}
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'https://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-m4_v16_en.html'],
+			model: 'M4',
+			setup: {
+				rotors: ['Beta', 'II', 'VII', 'V'],
+				plugs: 'YL SF VO AI BX WC KD MT JN PH',
+				ringSettings: [9, 18, 12, 8],
+				reflector: 'Thin-B'
+			},
+			message: {
+				key: 'MKDM',
+				encoded: 'KEKZCUAFFTWOHZURZPCTWWCICFOGAXBTCTPHMAIFXEEBAYFCQOOAGFKWAHOFEUYWBUEZIWADYATCTLEOUGRPSQDTBZCHIGQGBCXBRYDSGFDBEURKHUKFUYHALYROROKIZWFTPEJJUIRGBIQFGPLGWXJPMNPSEHYSGITZCGSMZXVVJCRXZQWGMOKNBTYVRMYHPWMEXGPUSHYQEWIDZTITRUFXLPYAQUCZVDCAVCMWGGQMXEQDFPTBLOJDEGTGKXXWFIGASTKMLWHFOPPXNBVDYUHDNOJNATOTMWLJGLSTJXDDHGKOBZCPNTPLPKINICEWVJUUNVKDYWGVFFJE',
+				decoded: 'YOUNGFORTINBRASWITHCONQUESTCOMEFROMPOLANDTOTHEAMBASSADORSOFENGLANDGIVESTHISWARLIKEVOLLEYNOUPSWORDANDKNOWTHOUAMOREHORRIDHENTWHENHEISDRUNKASLEEPORINHISRAGEORINTHEINCESTUOUSPLEASUREOFHISBEDATGAMINGSWEARINGORABOUTSOMEACTTHATHASNORELISHOFSALVATIONINTTHENTRIPHIMTHATHISHEELSMAYKICKATHEAVENANDTHATHISSOULMAYBEASDAMNDANDBLACKASHELLWHERETOITGOES'
+			}
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'https://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-m4_v16_en.html'],
+			model: 'M4',
+			setup: {
+				rotors: ['Gamma', 'VIII', 'VI', 'V'],
+				plugs: 'RX VA HE ST QL UK PG DB JZ OC',
+				ringSettings: [7, 14, 19, 26],
+				reflector: 'Thin-C'
+			},
+			message: {
+				key: 'IBFP',
+				encoded: 'PUEDVIRAVXYTNFBCUGMSVLVZYRREYMERJCSCKSCACKBZNZNNLYFAAUIKFRMIIUPWBFSFWVKRYLMKHXKXGJXRFQJNRSLSFGFBBKEVQPWCLKUBMNUUKWIYSUQXAXOGZKSBVCRXMIMNJKOXCUBFXSGYQVUXSAWOFQVDQIYTULXKZXEKCQGXQXFVADTSSVZZGQMHBBMJQBYLUWAJELOIYICWTDZQAQYPBCAGKHTICILGFKMNRRXGRUTADCIOCQBXHODIRWXARKENICHVMVHWRRIVWWDCG',
+				decoded: 'IFYOUDOMEETHORATIOANDMARCELLUSTHERIVALSOFMYWATCHBIDTHEMMAKEHASTETHEGREATMANDOWNYOUMARKHISFAVOURITEFLIESTHEPOORADVANCEDMAKESFRIENDSOFENEMIESOWONDERFULGOODMYLORDTELLITFORGIVEMETHISMYVIRTUEFORINTHEFATNESSOFTHESEPURSYTIMESVIRTUEITSELFOFVICEMUSTPARDONBEGYEACURBANDWOOFORLEAVETODOHIMGOOD'
+			}
+		},
+		{
+			verified: ['https://cryptii.com/pipes/enigma-machine', 'https://people.physik.hu-berlin.de/~palloks/js/enigma/enigma-m4_v16_en.html'],
+			model: 'M4',
+			setup: {
+				rotors: ['Gamma', 'II', 'VIII', 'VII'],
+				plugs: 'SA LM XY CV ER GB KT PJ WH DU',
+				ringSettings: [25, 21, 11, 2],
+				reflector: 'Thin-B'
+			},
+			message: {
+				key: 'TQXV',
+				encoded: 'NWWKWEOXQKVGAFEMANRTAEGIZIROXKLPEFTWZJEHQVXDIDDXYIDASSXZJUSZTDHEUKPUVNTOONBYOZJAGCMTEFYHCSJCHOHGMXWHLZAVCBRVNGAMTFUNZNVWPAWBXUICZCYKDBSKJZBQPOMBJCJVKSIGJXAXBDZLYAGPSVATCLXXEQVIWUKBOP',
+				decoded: 'COMEHITHERGENTLEMENANDLAYYOURHANDSAGAINUPONMYSWORDNEVERTOSPEAKOFTHISTHATYOUHAVEHEARDSWEARBYMYSWORDSEEITSTALKSAWAYSTAYSPEAKSPEAKICHARGETHEESPEAKTISGONEANDWILLNOTANSWERISHALLOBEYMYLORD'
+			}
+		}
+	]
+}

package/lib/enigma/tests/EnigmaSpec.js

@@ -0,0 +1,123 @@
+
+import '../standardInventory.js';
+import Enigma from "../Enigma.js";
+
+import { enigmaData } from './EnigmaData.js';
+
+describe('Enigma Test Cases', function() {
+	var enigma;
+/*
+	describe('Configuration', function() {
+
+	})
+*/
+
+	function messageLoop(messages, which, cb) {
+		messages.find(function(message) {
+			var enigma = new Enigma({
+				reflector: message.setup.reflector
+			});
+
+			enigma.configure({
+				plugs: message.setup.plugs,
+				rotors: message.setup.rotors,
+				ringSettings: message.setup.ringSettings
+			})
+
+			var toEncode = message.message[which]
+			var encoded = enigma.encode(message.message.key,toEncode);
+			return cb(message, encoded);
+		})
+	}
+
+	describe('Stepping', function() {
+		var steps = {}
+		beforeEach(function() {
+			enigma = new Enigma({
+				reflector: 'B',
+			});
+
+			enigma.configure({rotors: ['I', 'II', 'III']});
+
+			enigma.listen(function(event, name, message, info) {
+				if (event === 'step') {
+					steps[name] = steps[name] || [];
+					steps[name].push(info);
+				}
+			})
+
+		});
+
+		it ('should step only the right-most rotor when not at turnover', function() {
+			steps = {};
+			enigma.encode('AAA', 'A');
+			var stepped = Object.keys(steps);
+			expect(stepped.length).toBe(1);
+			expect(stepped[0]).toBe('rotor-III');
+		});
+
+		it ('should step the next rotor when the previous turns over', function() {
+			steps = {};
+			enigma.encode('AAV', 'A');
+			expect(steps['rotor-II'].length).toBe(1);
+		});
+
+		it ('should double step when reaching the turn over', function() {
+			steps = {};
+			enigma.encode('ADV', 'AA');
+			expect(steps['rotor-II'].length).toBe(2);
+		});
+
+		it ('should double step on first step', function() {
+			steps = {};
+
+			enigma.configure({rotors: ['III', 'VI', 'VIII'], ringSettings: [1, 8, 13]});
+
+			enigma.encode('UZV', 'AA');
+			expect(steps['rotor-VI'].length).toBe(1);
+		});
+	})
+
+	describe('Encoding', function() {
+		it('Should encode sample field messages', function() {
+			var messages = enigmaData.sampleFieldMessages;
+
+			var fail = messageLoop(messages, 'decoded', function(message, decoded) {
+				return decoded !== message.encoded;
+			})
+
+			expect(fail).toBeUndefined();
+		});
+
+		it('Should decode sample field messages', function() {
+			var messages = enigmaData.sampleFieldMessages;
+
+			var fail = messageLoop(messages, 'encoded', function(message, decoded) {
+				return decoded !== message.decoded;
+			})
+
+			expect(fail).toBeUndefined();
+		})
+
+		it('Should encode sample verified messages', function() {
+			var messages = enigmaData.sampleVerifiedMessages;
+
+			var fail = messageLoop(messages, 'decoded', function(message, decoded) {
+				return decoded !== message.encoded;
+			})
+
+			expect(fail).toBeUndefined();
+		});
+
+		it('Should decode sample verified messages', function() {
+			var messages = enigmaData.sampleVerifiedMessages;
+
+			var fail = messageLoop(messages, 'encoded', function(message, decoded) {
+				return decoded !== message.decoded;
+			})
+
+			expect(fail).toBeUndefined();
+		})
+
+	})
+})

package/lib/enigma/tests/PlugBoardData.js

@@ -0,0 +1,4 @@
+export const plugBoardData = {
+	alphabet: 'ABCDEFG',
+	plugSettings: 'AB FG',
+}

package/lib/enigma/tests/PlugBoardSpec.js

@@ -0,0 +1,46 @@
+import PlugBoard from "../PlugBoard.js";
+import { plugBoardData } from './PlugBoardData.js';
+
+describe('PlugBoard Test Cases', function() {
+    var plugBoard;
+
+    describe('Encode', function() {
+        beforeEach(function() {
+            plugBoard = new PlugBoard('test-plugboard', {
+                alphabet: plugBoardData.alphabet,
+            });
+        })
+
+        it('passes through if no plugs defined', function() {
+            plugBoard.configure()
+            var alphabet = [...plugBoardData.alphabet];
+            alphabet.forEach(function(letter) {
+                var input = plugBoardData.alphabet.indexOf(letter);
+                var output = plugBoard.encode('right', input);
+                expect(output).toBe(input);
+                var output = plugBoard.encode('left', input);
+                expect(output).toBe(input);
+            })
+        });
+
+        it('should link cabled pairs', function() {
+            plugBoard.configure({plugs: plugBoardData.plugSettings});
+            var pairs = plugBoardData.plugSettings.split(' ');
+            var alphabet = plugBoardData.alphabet;
+            pairs.forEach(function(pair) {
+                var left = alphabet.indexOf(pair[0]);
+                var right = alphabet.indexOf(pair[1]);
+
+                var output = plugBoard.encode('right', left);
+                expect(output).toBe(right);
+                var output = plugBoard.encode('right', right);
+                expect(output).toBe(left);
+
+                var output = plugBoard.encode('left', right);
+                expect(output).toBe(left);
+                var output = plugBoard.encode('left', left);
+                expect(output).toBe(right);
+            })
+        })
+    })
+})