@ondoher/enigma 0.1.0

package/lib/enigma/Encoder.js

@@ -0,0 +1,102 @@
+import { STANDARD_ALPHABET } from "./consts.js";
+
+/**
+ * This is the listener for Enigma and component events
+ * @callback Listener
+ * @param {String} event a string that identifies the event being fired
+ * @param {String} name the name of the component firing the event
+ * @param {String} message a human readable description of the evebnt details
+ * @param {Object} into event specific data for the event
+ */
+
+/**
+ * This is the base class for an encoder. The default implementation of the
+ * encode method is to return the input as the output
+ */
+export default class Encoder {
+	constructor(name, {cb, alphabet = STANDARD_ALPHABET}) {
+		this.name = name;
+		this.alphabet = alphabet;
+		this.contactCount = alphabet.length;
+		this.cb = cb;
+	}
+
+	/**
+	 * given a connector number, normalize it to be between 0 and 25 inclusive.
+	 *
+	 * @param {Number} connector the connector being normalized
+	 *
+	 * @returns {Number} value between 0 and 25
+	 */
+	normalize(connector) {
+		return (connector + this.contactCount * 2) % this.contactCount;
+	}
+
+	/**
+	 * Given an alphabetic connection map, convert that into an array of
+	 * numbers. The index into the array or string is the input connector, and
+	 * the value at that position is the output connector
+	 *
+	 * @param {String} map connections map.
+	 * @returns {Array.<Number>} the numerical map
+	 */
+	makeMap(map) {
+		var letters = [...map];
+		return letters.map(function(letter) {
+			return this.alphabet.indexOf(letter);
+		}, this)
+	}
+
+	/**
+	 * given an existing connection map from inoput to out put, create a new map
+	 * that has the connections going in the other direction, output to input.
+	 *
+	 * @param {Array.<Number>} map connection map
+	 * @returns {Array.<Number>} the reversed map
+	 */
+	makeReverseMap(map) {
+		var reverseMap = new Array(map.length);
+
+		map.forEach(function(input, idx) {
+			reverseMap[input] = idx;
+		}, this);
+
+		return reverseMap;
+	}
+
+	/**
+	 * Call this method to convert the input connector number to the output in
+	 * the given direction The default encode method just passes the input value
+	 * through
+	 *
+	 * @param {String} direction either right for moving towards the reflector
+	 * 	or left if moving back
+	 * @param {Number} input the specific connection receiving an input
+	 *
+	 * @returns {Number} The translated output connector number
+	 */
+	encode(direction, input) {
+		return input;
+	}
+
+	/**
+	 * Call this method to set a function to be called when important events
+	 * happen to a component.
+
+	 * @param {Listener} cb the function to be called.
+	 */
+	listen(cb) {
+		this.cb = cb;
+	}
+
+	/**
+	 * Call this method to call the event listener
+	 *
+	 * @param {String} name the name of the event
+	 * @param  {...any} rest the parameters to pass to the callback
+	 */
+	fire(name, ...rest) {
+		if (this.cb) this.cb(name, ...rest);
+	}
+
+}

package/lib/enigma/Enigma.js

@@ -0,0 +1,246 @@
+import EntryDisc from "./EntryDisc.js";
+import PlugBoard from "./PlugBoard.js";
+import Rotor from "./Rotor.js";
+import Reflector from "./Reflector.js";
+import inventory from './Inventory.js'
+import { STANDARD_ALPHABET } from "./consts.js";
+
+/**
+ * Construct this class to get a new instance of the Enigma. Many of the
+ * parameters to the constructor and the config method reference the names of
+ * standard Enigma parts. These are retrived from the Inventory instance
+ */
+export default class Enigma {
+	/**
+	 * The constructor for the Enigma. This represents the unconfigurable
+	 * settings of the device.
+	 *
+	 * @param {Object} settings the settings for the Enigma
+	 * @property {String} [entryDisc] the name of entry disc in the inventory
+	 * this defaults 'default'
+	 * @param {String} reflector specifies one of possible reflectors, the
+	 * predefined reflectors are A, B, C, Thin-B and Thin-C
+	 * @param {String} [alphabet] the alphabet used by the system, usually just
+	 *	the uppercase latin letters
+	 */
+	constructor(settings) {
+		var {entryDisc = 'default', reflector, alphabet = STANDARD_ALPHABET} = settings;
+		var entryDiscSettings = inventory.getEntryDisc(entryDisc)
+
+		var reflectorSettings = inventory.getReflector(reflector)
+		this.alphabet = alphabet;
+		this.plugboard = new PlugBoard('plugboard', {});
+		this.entryDisc = new EntryDisc('entry-disc', entryDiscSettings);
+		this.reflector = new Reflector('reflector', reflectorSettings)
+		this.length = alphabet.length;
+	}
+
+	/**
+	 * Call this method to normalize a connector number to be within the
+	 * the length of the currrent alphabet
+	 *
+	 * @param {Number} connector the number to be normalized
+	 *
+	 * @returns {Number} the normalized connector number
+	 */
+	normalize(connector) {
+		connector += this.length;
+		connector = connector % this.length
+
+		return connector;
+	}
+
+	/**
+	 * Configure the Enigma for encoding.
+	 *
+	 * @param {Object} settings the configuration of the Enigma. These settings
+	 * represent the aspects of the Enigma that can can change for daily
+	 * configuration.
+	 * @property {Array.<String>|String} [plugs] array of strings with each
+	 * 	element being a pair of letters from the alphabet that are being swapped
+	 * 	on the plug board
+	 * @property {Array.<String>} rotors the array of installed rotors. The
+	 * 	order here is signicant and is given in the left to right direction.
+	 * 	This means that last name in this list is the first rotor used in the
+	 * 	forward direction and last used in the backward direction. Each element
+	 * 	is the name of the rotor to use in the corresponding position. Stepping
+	 * 	stops at the first fixed rotor
+	 * @property {String|Array<Number>} [ringSettings] each letter in this
+	 * 	string represents the offset of the key settings from the rotor start
+	 * 	position. If it is an array, then each value is the one based key
+	 * 	setting for the related rotor,
+	 */
+	configure(settings) {
+		var { rotors, ringSettings = [], plugs = [] } = settings;
+
+		// make copies of these configurations so that we don't change the
+		// values from the caller, which in JavaScript are passed by reference.
+		rotors = JSON.parse(JSON.stringify(rotors));
+		ringSettings = JSON.parse(JSON.stringify(ringSettings));
+
+		// the rotors are given in the left to right direction, but are actually
+		// used in the right to left direction. So, here we reverse them
+		rotors = rotors.reverse();
+
+		this.plugboard.configure({plugs})
+
+		var ringOffsets = []
+
+		// because the rotors are secified in the reverse other they are used,
+		// we have to do the same for the ringSettings.
+		if (Array.isArray(ringSettings)) {
+			ringSettings = ringSettings.reverse();
+
+			// When specified with numbers they will be in the range 1-26, we
+			// need to shift these to be 0-25;
+			ringSettings.forEach(function(offset) {
+				ringOffsets.push(this.normalize(offset - 1))
+			}, this);
+		} else {
+			var letters = [...ringSettings];
+			letters = letters.reverse();
+			letters.forEach(function(letter) {
+				var offset = this.alphabet.indexOf(letter);
+				ringOffsets.push(offset);
+			}, this)
+		}
+
+		this.rotors = rotors.map(function(name, idx) {
+			return new Rotor(`rotor-${name}`, {...inventory.getRotor(name), alphabet: this.alphabet, ringSetting: ringOffsets[idx], cb: this.cb});
+		}, this);
+
+		this.encoders = [this.plugboard, this.entryDisc, ...this.rotors];
+	}
+
+	/**
+	 * Call this method to step the rotors one time. This method will manage the
+	 * stepping between all rotors
+	 */
+	step() {
+		this.rotors.forEach(function(rotor, idx) {
+			if (rotor.isFixed()) return;
+
+			// This is the double stepping. Only do this for the middle rotor
+			if (rotor.willTurnover() && idx === 1) {
+				this.pending[idx] = true
+			};
+
+			if (this.pending[idx]) {
+				this.pending[idx] = false;
+				if (rotor.step()) this.pending[idx + 1] = true;
+			}
+		}, this);
+
+		// The first rotor is always stepping
+		this.pending[0] = true;
+	}
+
+	/**
+	 * Call this method to set the starting rotation for the messages to encrypt
+	 *
+	 * @param {Array.Number>|String} the length of the string or the array
+	 * 	should match the number of rotors and are given left to right. If start
+	 * 	is a string then the letters of the string specify the start value seen
+	 * 	in the window for the corresponding rotor. If it is an array then each
+	 * 	number will be the one-based rotation.
+	 */
+	setStart(start) {
+		if (Array.isArray(start)) {
+			var charArray = start.map(function(number) {
+				number--;
+				return this.alphabet[number];
+			}, this);
+
+			start = charArray.join('');
+		}
+		start = [...start].reverse();
+
+		// reset the rotation pending state
+		this.pending = {0: true};
+
+		this.rotors.forEach(function(rotor, idx) {
+			rotor.setStartPosition(start[idx]);
+		})
+	}
+
+	/**
+	 * Call this method to simulate a keypress on the Enigma. This will output
+	 * the encoded letter
+	 *
+	 * @param {String} letter the key pressed
+	 * @returns {String} the encoded letter
+	 */
+	keyPress(letter) {
+		letter = letter.toUpperCase();
+		if (letter.length !== 1 || this.alphabet.indexOf(letter) === -1) {
+			if (letter !== ' ')
+				console.warn(`Unexected character ${letter}`);
+			return;
+		}
+
+		this.fire('input', this.name, `input ${letter}`, {letter})
+		this.step();
+
+		// encode to the right
+		var connector =  this.encoders.reduce(function(connector, encoder) {
+			connector = encoder.encode('right', connector);
+			return connector;
+		}.bind(this), this.alphabet.indexOf(letter));
+
+		// reflector
+		connector = this.reflector.encode('', connector);
+
+		// encode to the left
+		connector = this.encoders.reduceRight(function(connector, encoder) {
+			connector = encoder.encode('left', connector);
+			return connector;
+		}.bind(this), connector)
+
+		letter = this.alphabet[connector];
+		this.fire('output', this.name, `output ${letter}`, {letter})
+		return letter;
+	}
+
+	/**
+	 * Call this shortcut method to encode a whole string
+	 *
+	 * @param {String} start the starting positon for the rotors
+	 * @param {String} text the text to encode
+	 *
+	 * @returns {String} the encoded string.
+	 */
+	encode(start, text) {
+		this.setStart(start)
+		var letters = [...text];
+		var output = letters.map(function(letter) {
+			return this.keyPress(letter);
+		}, this)
+
+		return output.join('');
+	}
+
+	/**
+	 * Call this method to call the event listener
+	 *
+	 * @param {String} name the name of the event
+	 * @param  {...any} rest the parameters to pass to the callback
+	 */
+	fire(type, ...rest) {
+		if (this.cb) this.cb(type, ...rest);
+	}
+
+	/**
+	 * Call this method to set a function to be called when important events
+	 * happen to a component.
+
+	 * @param {Listener} cb the function to be called.
+	 */
+	listen(cb) {
+		this.cb = cb;
+		this.encoders.forEach(function(encoder) {
+			encoder.listen(cb);
+		});
+
+		this.reflector.listen(cb);
+	}
+}

package/lib/enigma/EntryDisc.js

@@ -0,0 +1,36 @@
+import Encoder from './Encoder.js';
+import { STANDARD_ALPHABET } from "./consts.js";
+
+
+/**
+ * This is the class for an entry disc. Entry discs are fixed disks of connector
+ * pins.
+ */
+export default class EntryDisc extends Encoder {
+	/**
+	 * Constuctor for the entry disc.
+	 *
+	 * @param {String} name thge name of this entry disc
+	 * @param {Object} settings contains the alphabet being used, and the map
+	 * 	between input and output contacts
+	 */
+	constructor(name, settings) {
+		super(name, settings);
+		var {map} = settings;
+		this.rightMap = this.makeMap(map);
+		this.leftMap = this.makeReverseMap(this.rightMap);
+	}
+
+	encode(direction, input) {
+		var result = direction === 'right' ? this.rightMap[input]: this.leftMap[input];
+		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
+
+		this.fire(evName, this.name,
+			`${evName} ${this.name}, input: ${input}, output: ${result}`, {
+				input: input,
+				output: result,
+			}
+		);
+		return result;
+	}
+}

package/lib/enigma/Inventory.js

@@ -0,0 +1,115 @@
+/**
+ * This is the class used to manage the standard inmventory of components. An
+ * instance of this class is exported as the default of this module
+ */
+
+class Inventory {
+	/**
+	 * Constructor for the inventory class. Starts out empty
+	 */
+	constructor() {
+		this.entryDiscs = {};
+		this.rotors = {};
+		this.fixedRotors = {};
+		this.reflectors = {};
+	}
+
+	/**
+	 * Call this method to add a new Rotor type to the inventory.
+	 *
+	 * @param {String} name the name of the rotor being added. This name will be
+	 * 	used when specifying the rotors to use for the Enigma configuration.
+	 * @param {String} map a string specifying the connector mapping. The index
+	 * 	of the string is the logical coordinate of the connector, the character
+	 * 	at that index is the output connector. To be exact, it would be the
+	 * 	position of that character in the given alphabet. So, in the map '
+	 * 	EKMFLGDQVZNTOWYHXUSPAIBRCJ', input connector 0 would map to output
+	 * 	connector 4 and input connector 1 would map to output connector 10.
+	 * 	Remember that the connectors are numbered starting at 0.
+	 * @param {String} turnovers this is a string of characters representing the
+	 * 	turnover locations on the disk. These letter would be the value shown in
+	 * 	the window to during turnover. In Rotor I this is 'Q' in rotors VI, VII,
+	 * 	and VIII there are two turnover locations, 'M' and 'Z'. Pass an empty
+	 * 	string if this is a fixed rotor
+	 */
+
+	addRotor(name, map, turnovers) {
+		this.rotors[name] = {map, turnovers}
+	}
+
+	/**
+	 * Call this method to add a new reflector definition.
+	 *
+	 * @param {String} name this is the name that will be used to reference this
+	 * 	reflector when constructing an Enigma class.
+	 * @param {String} map the mapping between connectors. this uses the same
+	 * 	format used in the addRotor method
+	 */
+	addReflector(name, map) {
+		this.reflectors[name] = {map};
+	}
+
+	/**
+	 * Call this method to add a new entry disc. There was only one used in the
+	 * standard military models, but there were other versions that defined it
+	 * differently.
+	 *
+	 * @param {*} name this is the name that will be used to reference this
+	 * 	entry disc when constructing an Enigma class.
+	 * @param {*} map the mapping between connectors. this uses the same format
+	 * 	used in the addRotor method
+	 */
+	addEntryDisc(name, map) {
+		this.entryDiscs[name] = {map};
+	}
+
+	/**
+	 * Call this method to get the setup for a defined rotor.
+	 *
+	 * @param {String} name the name of the rotor as it was added to the
+	 * 	inventory.
+	 *
+	 * @returns {Object} the rotor defintion
+	 * @property {String} map the connection map for the rotor
+	 * @property {String} turnovers the locations where turnovers happen
+	 */
+	getRotor(name) {
+		return this.rotors[name];
+	}
+
+	/**
+	 * Call this method to get the setup for a defined reflector.
+	 *
+	 * @param {String} name the name of the reflector as it was added to the
+	 * 	inventory.
+	 * @returns {Object} the reflector definition
+	 * @property {String} the connection map for the reflector
+	 */
+	getReflector(name) {
+		return this.reflectors[name];
+	}
+
+	/**
+	 * Call this method to get the setup for a defined entry disc.
+	 *
+	 * @param {String} name the name of the entry disc as it was added to the
+	 * 	inventory.
+	 * @returns {Object} the entry disc definition
+	 * @property {String} the connection map for the entry disc
+	 */
+	getEntryDisc(name) {
+		return this.entryDiscs[name];
+	}
+
+	/**
+	 * Call this method to get the names of all the rotors in the inventory
+	 *
+	 * @returns {Array.<String>} the names of the rotors
+	 */
+	getRotorNames() {
+		return Object.keys(this.rotors);
+	}
+}
+
+
+export default new Inventory();

package/lib/enigma/PlugBoard.js

@@ -0,0 +1,74 @@
+import Encoder from "./Encoder.js";
+import { STANDARD_ALPHABET } from "./consts.js";
+
+/**
+ * This class represents the plugboard. There is only one type of plugboard
+ */
+export default class PlugBoard extends Encoder {
+
+	/**
+	 * Constructor for the plugboard.
+	 *
+	 * @param {String} name the name for the plugboard, defaults to 'plugboard'
+	 * @param {Object} [settings] the settings for the plugboard. Only needed if
+	 * 	using an alternate alphabet
+	 */
+	constructor(name = 'plugboard', settings = {}) {
+		super(name, settings);
+
+		var {alphabet = STANDARD_ALPHABET, map} = settings;
+		this.alphabet = alphabet;
+		this.map = map || alphabet;
+	}
+
+	/**
+	 * Call this method to configure the plug board. This will be used to
+	 * provide the plug connections
+	 *
+	 * @param {Object} [settings] the configuration options for the plug
+	 * 	board
+	 * @property {Array.<String>|String} [plugs] either an array of strings or a
+	 * 	single string. If it is a string, it must be a space separated list of
+	 * 	letter pairs that connects one input letter to another. If it is an
+	 * array then then each item is a pair of letters to specify how the plugs
+	 * are connected
+	 */
+	configure(settings = {}) {
+		var map = this.map;
+		var {plugs = []} = settings;
+
+		if (typeof plugs === 'string') plugs = plugs.split(' ');
+		plugs.forEach(function(plug) {
+			var firstIdx = this.alphabet.indexOf(plug[0]);
+			var secondIdx = this.alphabet.indexOf(plug[1]);
+			var first = map[firstIdx];
+			var second = map[secondIdx];
+			map = map.slice(0, firstIdx) + second + map.slice(firstIdx + 1);
+			map = map.slice(0, secondIdx) + first + map.slice(secondIdx + 1);
+		}, this)
+
+		this.rightMap = this.makeMap(map);
+		this.leftMap = this.makeReverseMap(this.rightMap);
+	}
+
+	/**
+	 * Call this method to convert the input connector number to the output in
+	 * the given direction.
+	 *
+	 * @param {String} direction either right for moving towards the reflector or
+	 * 	left if moving back
+	 * @param {Number} input the input connector
+	 * @returns {Number} the output connector
+	 */
+	encode(direction, input) {
+		var result = direction === 'right' ? this.rightMap[input]: this.leftMap[input];
+		var evName = direction === 'right' ? 'encode-right' : 'encode-left';
+		this.fire(evName, this.name,
+			`${evName} ${this.name}, input: ${input}, output: ${result}`, {
+				input: input,
+				output: result,
+			}
+		);
+		return result;
+	}
+}

package/lib/enigma/Reflector.js

@@ -0,0 +1,51 @@
+import Encoder from './Encoder.js';
+import { STANDARD_ALPHABET } from './consts.js';
+
+/**
+ * Make in instance of this class to construct a reflector
+ */
+export default class Reflector extends Encoder {
+
+	/**
+	 * constructor for the reflector class.
+	 *
+	 * @param {String} name the name of the reflector instance
+	 * @param {Obect} The definition of the reflector
+	 * @property {String} [alphabet] 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, 'YRUHQSLDPXNGOKMIEBFZCWVJAT' which is the map for
+	 * standard reflector B.
+	 */
+	constructor(name, settings) {
+		super(name, settings);
+		var {map} = settings;
+
+ 		this.map = this.makeMap(map);
+	}
+
+	/**
+	 * Call this method when reversing the encoding direction of the Enigma. As
+	 * the point where direction changes this does not have a distinction
+	 * between a left and right signal path.
+	 *
+	 * @param {String} direction since this is the point where signal direction
+	 * changes from right to left this parameter is not used.
+	 * @param {Number} input this is the input connector
+	 *
+	 * @returns {Number} the mapped output connector
+	 */
+	encode(direction, input) {
+		var result = this.map[input];
+		this.fire('encode', this.name,
+			`encode ${this.name} ${input} ${result}`,
+			{
+				input: input,
+				output: result,
+			});
+
+		return result;
+	}
+}