@ondoher/enigma 0.1.7 → 1.0.0

package/lib/enigma/Rotor.js

@@ -1,3 +1,4 @@
+import { STANDARD_ALPHABET } from "./consts.js";
 import Encoder from "./Encoder.js";
 
 /**
@@ -6,49 +7,18 @@ import Encoder from "./Encoder.js";
  * 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
+	 * @param {RotorSetup} 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
+		var { map = STANDARD_ALPHABET, turnovers = '', ringSetting = 0} = settings
 
 		this.map = [...map];
 		this.rightMap = this.makeMap(map);
@@ -105,7 +75,7 @@ export default class Rotor extends Encoder {
 		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}`,
+			`${evName} ${this.name}, input: ${input} output: ${result} relative input: ${index}, relative output: ${output} rotation: ${this.offset}`,
 			{
 				input : input,
 				output: result,
@@ -125,7 +95,7 @@ export default class Rotor extends Encoder {
 	 */
 	step() {
 		// Because the turnover notch is attached to the outer ring, and the
-		// logical coordinates is based on the wiring, the logical position of
+		// logical coordinates are 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);

package/lib/enigma/standardInventory.js

@@ -5,7 +5,7 @@ import inventory from'./Inventory.js';
  * I, M3 and M4
  */
 
-export var entryDiscDefintions = {
+export var entryDiscDefinitions = {
 	default: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
 };
 
@@ -74,7 +74,7 @@ function addReflector(name) {
 	inventory.addReflector(name, reflectorDefinitions[name]);
 }
 
-inventory.addEntryDisc('default', entryDiscDefintions.default);
+inventory.addEntryDisc('default', entryDiscDefinitions.default);
 
 addRotor('I');
 addRotor('II');

package/lib/enigma/tests/EnigmaSpec.js

@@ -6,11 +6,6 @@ import { enigmaData } from './EnigmaData.js';
 
 describe('Enigma Test Cases', function() {
 	var enigma;
-/*
-	describe('Configuration', function() {
-
-	})
-*/
 
 	function messageLoop(messages, which, cb) {
 		return messages.find(function(message) {

package/lib/enigma/tests/PlugBoardSpec.js

@@ -2,7 +2,8 @@ import PlugBoard from "../PlugBoard.js";
 import { plugBoardData } from './PlugBoardData.js';
 
 describe('PlugBoard Test Cases', function() {
-    var plugBoard;
+    /** @type {PlugBoard} */
+    let plugBoard;
 
     describe('Encode', function() {
         beforeEach(function() {
@@ -13,32 +14,32 @@ describe('PlugBoard Test Cases', function() {
 
         it('passes through if no plugs defined', function() {
             plugBoard.configure()
-            var alphabet = [...plugBoardData.alphabet];
+            let alphabet = [...plugBoardData.alphabet];
             alphabet.forEach(function(letter) {
-                var input = plugBoardData.alphabet.indexOf(letter);
-                var output = plugBoard.encode('right', input);
+                let input = plugBoardData.alphabet.indexOf(letter);
+                let output = plugBoard.encode('right', input);
                 expect(output).toBe(input);
-                var output = plugBoard.encode('left', input);
+                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;
+            plugBoard.configure(plugBoardData.plugSettings);
+            let pairs = plugBoardData.plugSettings.split(' ');
+            let alphabet = plugBoardData.alphabet;
             pairs.forEach(function(pair) {
-                var left = alphabet.indexOf(pair[0]);
-                var right = alphabet.indexOf(pair[1]);
+                let left = alphabet.indexOf(pair[0]);
+                let right = alphabet.indexOf(pair[1]);
 
-                var output = plugBoard.encode('right', left);
+                let output = plugBoard.encode('right', left);
                 expect(output).toBe(right);
-                var output = plugBoard.encode('right', right);
+                output = plugBoard.encode('right', right);
                 expect(output).toBe(left);
 
-                var output = plugBoard.encode('left', right);
+                output = plugBoard.encode('left', right);
                 expect(output).toBe(left);
-                var output = plugBoard.encode('left', left);
+                output = plugBoard.encode('left', left);
                 expect(output).toBe(right);
             })
         })

package/lib/enigma/tests/RotorSpec.js

@@ -41,7 +41,7 @@ describe('Rotor Test Cases', function() {
 			});
 		});
 
-		describe('startPositon', function() {
+		describe('startPosition', function() {
 			it('no Rotation', function() {
 				rotor.setStartPosition('A');
 				expect(rotor.offset).toBe(0)

package/lib/generator/CodeBook.js

@@ -0,0 +1,180 @@
+
+import Enigma from '../enigma/Enigma.js';
+import '../enigma/standardInventory.js';
+import sentences from './hamlet.js'
+import { STANDARD_ALPHABET } from '../enigma/consts.js';
+import Random from '../utils/Random.js';
+import Generator from './Generator.js';
+
+/**
+ * Use this class to generate Enigma key sheets and messages using it. The
+ * procedures used were derived from the information at
+ * [Enigma Message Procedures](https://www.ciphermachinesandcryptology.com/en/enigmaproc.htm)
+ */
+export default class CodeBook {
+	/**
+	 * Constructor for the `CodeBook` class.
+	 * @param {Enigma} enigma - all encryption will be done using this configured Enigma
+	 */
+	constructor(enigma) {
+		this.enigma = enigma
+		this.indicators = {};
+		this.generator = new Generator();
+	}
+
+	/**
+	 * Call this method to provide a new configuration to the enigma
+	 *
+	 * @param {SimplifiedConfiguration} config
+	 */
+	configure(config) {
+		this.enigma.configure(config);
+	}
+
+	reset() {
+		this.indicators = {}
+	}
+
+	/**
+	 * Call this method to create a three letter string as an identifier for a
+	 * a day in a key sheet
+	 *
+	 * @returns {String} the string
+	 */
+	makeIndicator() {
+		let letters = [...'abcdefghijklmnopqrstuvwxyzx'];
+		let indicator;
+
+		do {
+			indicator = Random.choose(3, letters).join('');
+		} while (this.indicators[indicator]);
+
+		this.indicators[indicator] = indicator;
+
+		return indicator;
+	}
+
+	/**
+	 * Call this method to create a single days configuration for a key sheet.
+	 * This an Enigma configuration plus the other metadata.
+	 *
+	 * @param {number} day the day of the month
+	 *
+	 * @returns {KeySheetLine} One line of a key sheet
+	 */
+	generateDay(day) {
+		let settings = this.generator.generateEnigmaConfiguration();
+		let indicators = [];
+
+		indicators.push(this.makeIndicator());
+		indicators.push(this.makeIndicator());
+		indicators.push(this.makeIndicator());
+		indicators.push(this.makeIndicator());
+
+		return {day, ...settings, indicators}
+	}
+
+	/**
+	 * Call this method to construct a key sheet for the given number of days
+	 *
+	 * @param {Number} days the number of days on the key sheet
+	 * @returns {KeySheetLine[]} the array of day objects
+	 */
+	generateKeySheet(days) {
+		let sheet = [];
+		this.indicators = {};
+
+		for(let idx = 0; idx < days; idx++) {
+			sheet.push(this.generateDay(idx))
+		}
+
+		return sheet;
+	}
+
+	/**
+	 * Call this method to process one sub-message from a longer message. This is
+	 * part of code to generate a message as the Enigma would have been used.
+	 *
+	 * @param {string[]} indicators the three letter code that can be sent to
+	 * 	reference the configuration of the Enigma. These will be used to cross
+	 * reference the message to the machine configuration on the key sheet
+	 * @param {String} text the cleaned up string to be encoded
+	 *
+	 * @returns {MessagePart} the encoded message segment
+	 */
+	encodeOnePart(indicators, text) {
+		let indicator = Random.chooseOne(indicators);
+		let paddedIndicator = (Random.choose(2, [...STANDARD_ALPHABET]).join('') + indicator).toUpperCase();
+
+		let key = Random.choose(3, [...STANDARD_ALPHABET]).join('');
+		let start = Random.choose(3, [...STANDARD_ALPHABET]).join('');
+		let enc = this.enigma.encode(key, start);
+		let clear = text;
+
+		text = text.replace(/ /g, '');
+		text = this.enigma.encode(start, text);
+		text = this.generator.groupText(text);
+		text = paddedIndicator + ' ' + text
+
+		return {key, enc, start, text, clear};
+	}
+
+	/**
+	 * Call this method to generate a full message based on the data in a key
+	 * sheet. The message constructed reflects an actual message as the Enigma
+	 * was really used. An individual message cannot be more than 250
+	 * characters, so longer messages are broken into multiple parts, each one
+	 * encoded with a unique key
+	 *
+	 * @param {KeySheetLine[]} sheet a key sheet generated using generateKeySheet
+	 * @param {number} [dayIdx] - if provided, specifies the day of the month for the message
+	 * @param {string} [text] - if provided, this is the text of the message to generate
+	 * @returns {KeyBookMessage} a list of encoded sub messages
+	 */
+	generateMessage(sheet, dayIdx, text) {
+		dayIdx = dayIdx === undefined ? Random.random(sheet.length) : dayIdx;
+		let day = sheet[dayIdx]
+		let count = Random.random(3) + 2;
+
+		this.enigma.configure({plugs: day.plugs, rotors: day.rotors, ringSettings: day.ringSettings})
+
+		text = text ?? this.generator.generateSentences(count);
+		text = this.generator.cleanMessage(text);
+		let messageParts = [];
+
+		while (text.length) {
+			let segment = text.slice(0, 245);
+			if (text.length)
+				text = text.slice(246);
+
+			messageParts.push(segment);
+		}
+
+		let messages = messageParts.map((part) => {
+			return this.encodeOnePart(day.indicators, part)
+		});
+
+		return {
+			options: this.enigma.configuration,
+			parts: messages
+		}
+	}
+
+	/**
+	 * Call this method to generate a given number of messages based on a
+	 * generated key sheet
+	 *
+	 * @param {Object} sheet  the generated key sheet
+	 * @param {Number} count - the number of messages to generate
+	 *
+	 * @returns {Array} the list of generated messages
+	 */
+	generateMessages(sheet, count) {
+		let result = [];
+		for (let idx = 0; idx < count; idx++) {
+			result.push(this.generateMessage(sheet));
+		}
+
+		return result;
+	}
+}