Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -6,6 +6,8 @@ docs/*
 !docs/*.conf.json
 !docs/*.ico
 .vscode
+.*.swp
+.DS_Store
 src/core/config/modules/*
 src/core/config/OperationConfig.json
 src/core/operations/index.mjs

CHANGELOG.md

@@ -2,6 +2,18 @@
 All major and minor version changes will be documented in this file. Details of patch-level version changes can be found in [commit messages](https://github.com/gchq/CyberChef/commits/master).
 
 
+### [8.27.0] - 2019-03-14
+- 'Enigma', 'Typex', 'Bombe' and 'Multiple Bombe' operations added [@s2224834] | [#516]
+- See [this wiki article](https://github.com/gchq/CyberChef/wiki/Enigma,-the-Bombe,-and-Typex) for a full explanation of these operations.
+- New Bombe-style loading animation added for long-running operations [@n1474335]
+- New operation argument types added: `populateMultiOption` and `argSelector` [@n1474335]
+
+### [8.26.0] - 2019-03-09
+- Various image manipulation operations added [@j433866] | [#506]
+
+### [8.25.0] - 2019-03-09
+- 'Extract Files' operation added and more file formats supported [@n1474335] | [#440]
+
 ### [8.24.0] - 2019-02-08
 - 'DNS over HTTPS' operation added [@h345983745] | [#489]
 
@@ -106,6 +118,9 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[8.27.0]: https://github.com/gchq/CyberChef/releases/tag/v8.27.0
+[8.26.0]: https://github.com/gchq/CyberChef/releases/tag/v8.26.0
+[8.25.0]: https://github.com/gchq/CyberChef/releases/tag/v8.25.0
 [8.24.0]: https://github.com/gchq/CyberChef/releases/tag/v8.24.0
 [8.23.1]: https://github.com/gchq/CyberChef/releases/tag/v8.23.1
 [8.23.0]: https://github.com/gchq/CyberChef/releases/tag/v8.23.0
@@ -142,6 +157,7 @@ All major and minor version changes will be documented in this file. Details of
 [@j433866]: https://github.com/j433866
 [@GCHQ77703]: https://github.com/GCHQ77703
 [@h345983745]: https://github.com/h345983745
+[@s2224834]: https://github.com/s2224834
 [@artemisbot]: https://github.com/artemisbot
 [@picapi]: https://github.com/picapi
 [@Dachande663]: https://github.com/Dachande663
@@ -180,6 +196,7 @@ All major and minor version changes will be documented in this file. Details of
 [#394]: https://github.com/gchq/CyberChef/pull/394
 [#428]: https://github.com/gchq/CyberChef/pull/428
 [#439]: https://github.com/gchq/CyberChef/pull/439
+[#440]: https://github.com/gchq/CyberChef/pull/440
 [#441]: https://github.com/gchq/CyberChef/pull/441
 [#443]: https://github.com/gchq/CyberChef/pull/443
 [#446]: https://github.com/gchq/CyberChef/pull/446
@@ -192,3 +209,5 @@ All major and minor version changes will be documented in this file. Details of
 [#468]: https://github.com/gchq/CyberChef/pull/468
 [#476]: https://github.com/gchq/CyberChef/pull/476
 [#489]: https://github.com/gchq/CyberChef/pull/489
+[#506]: https://github.com/gchq/CyberChef/pull/506
+[#516]: https://github.com/gchq/CyberChef/pull/516

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "8.26.3",
+  "version": "8.27.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {
@@ -5125,14 +5125,12 @@
         "balanced-match": {
           "version": "1.0.0",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "brace-expansion": {
           "version": "1.1.11",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "balanced-match": "^1.0.0",
             "concat-map": "0.0.1"
@@ -5152,8 +5150,7 @@
         "concat-map": {
           "version": "0.0.1",
           "bundled": true,
-          "dev": true,
-          "optional": true
+          "dev": true
         },
         "console-control-strings": {
           "version": "1.1.0",
@@ -5301,7 +5298,6 @@
           "version": "3.0.4",
           "bundled": true,
           "dev": true,
-          "optional": true,
           "requires": {
             "brace-expansion": "^1.1.7"
           }
@@ -5730,7 +5726,7 @@
     },
     "get-stream": {
       "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz",
+      "resolved": "http://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz",
       "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=",
       "dev": true
     },
@@ -6486,7 +6482,7 @@
     },
     "html-webpack-plugin": {
       "version": "3.2.0",
-      "resolved": "http://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-3.2.0.tgz",
+      "resolved": "https://registry.npmjs.org/html-webpack-plugin/-/html-webpack-plugin-3.2.0.tgz",
       "integrity": "sha1-sBq71yOsqqeze2r0SS69oD2d03s=",
       "dev": true,
       "requires": {
@@ -6611,7 +6607,7 @@
     },
     "http-proxy-middleware": {
       "version": "0.18.0",
-      "resolved": "https://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-0.18.0.tgz",
+      "resolved": "http://registry.npmjs.org/http-proxy-middleware/-/http-proxy-middleware-0.18.0.tgz",
       "integrity": "sha512-Fs25KVMPAIIcgjMZkVHJoKg9VcXcC1C8yb9JUgeDvVXY0S/zgVIhMb+qVswDIgtJe2DfckMSY2d6TuTEutlk6Q==",
       "dev": true,
       "requires": {
@@ -9530,7 +9526,7 @@
     },
     "parse-asn1": {
       "version": "5.1.1",
-      "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz",
+      "resolved": "http://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.1.tgz",
       "integrity": "sha512-KPx7flKXg775zZpnp9SxJlz00gTd4BmJ2yJufSc44gMCRrRQ7NSzAcSJQfifuOLgW6bEi+ftrALtsgALeB2Adw==",
       "dev": true,
       "requires": {
@@ -12148,6 +12144,28 @@
       "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz",
       "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc="
     },
+    "svg-url-loader": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/svg-url-loader/-/svg-url-loader-2.3.2.tgz",
+      "integrity": "sha1-3YaybBn+O5FPBOoQ7zlZTq3gRGQ=",
+      "dev": true,
+      "requires": {
+        "file-loader": "1.1.11",
+        "loader-utils": "1.1.0"
+      },
+      "dependencies": {
+        "file-loader": {
+          "version": "1.1.11",
+          "resolved": "https://registry.npmjs.org/file-loader/-/file-loader-1.1.11.tgz",
+          "integrity": "sha512-TGR4HU7HUsGg6GCOPJnFk06RhWgEWFLAGWiT6rcD+GRC2keU3s9RGJ+b3Z6/U73jwwNb2gKLJ7YCrp+jvU4ALg==",
+          "dev": true,
+          "requires": {
+            "loader-utils": "^1.0.2",
+            "schema-utils": "^0.4.5"
+          }
+        }
+      }
+    },
     "symbol-tree": {
       "version": "3.2.2",
       "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.2.tgz",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "8.26.3",
+  "version": "8.27.0",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",
@@ -69,6 +69,7 @@
     "sass-loader": "^7.1.0",
     "sitemap": "^2.1.0",
     "style-loader": "^0.23.1",
+    "svg-url-loader": "^2.3.2",
     "url-loader": "^1.1.2",
     "web-resource-inliner": "^4.2.1",
     "webpack": "^4.28.3",

src/core/Chef.mjs

@@ -89,23 +89,26 @@ class Chef {
             progress = err.progress;
         }
 
-        // Depending on the size of the output, we may send it back as a string or an ArrayBuffer.
-        // This can prevent unnecessary casting as an ArrayBuffer can be easily downloaded as a file.
-        // The threshold is specified in KiB.
-        const threshold = (options.ioDisplayThreshold || 1024) * 1024;
-        const returnType = this.dish.size > threshold ? Dish.ARRAY_BUFFER : Dish.STRING;
-
         // Create a raw version of the dish, unpresented
         const rawDish = this.dish.clone();
 
         // Present the raw result
         await recipe.present(this.dish);
 
+        // Depending on the size of the output, we may send it back as a string or an ArrayBuffer.
+        // This can prevent unnecessary casting as an ArrayBuffer can be easily downloaded as a file.
+        // The threshold is specified in KiB.
+        const threshold = (options.ioDisplayThreshold || 1024) * 1024;
+        const returnType =
+            this.dish.size > threshold ?
+                Dish.ARRAY_BUFFER :
+                this.dish.type === Dish.HTML ?
+                    Dish.HTML :
+                    Dish.STRING;
+
         return {
             dish: rawDish,
-            result: this.dish.type === Dish.HTML ?
-                await this.dish.get(Dish.HTML, notUTF8) :
-                await this.dish.get(returnType, notUTF8),
+            result: await this.dish.get(returnType, notUTF8),
             type: Dish.enumLookup(this.dish.type),
             progress: progress,
             duration: new Date().getTime() - startTime,

src/core/config/Categories.json

@@ -102,7 +102,11 @@
             "JWT Decode",
             "Citrix CTX1 Encode",
             "Citrix CTX1 Decode",
-            "Pseudo-Random Number Generator"
+            "Pseudo-Random Number Generator",
+            "Enigma",
+            "Bombe",
+            "Multiple Bombe",
+            "Typex"
         ]
     },
     {

src/core/lib/Bombe.mjs

@@ -0,0 +1,756 @@
+/**
+ * Emulation of the Bombe machine.
+ *
+ * @author s2224834
+ * @author The National Museum of Computing - Bombe Rebuild Project
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError";
+import Utils from "../Utils";
+import {Rotor, Plugboard, a2i, i2a} from "./Enigma";
+
+/**
+ * Convenience/optimisation subclass of Rotor
+ *
+ * This allows creating multiple Rotors which share backing maps, to avoid repeatedly parsing the
+ * rotor spec strings and duplicating the maps in memory.
+ */
+class CopyRotor extends Rotor {
+    /**
+     * Return a copy of this Rotor.
+     * @returns {Object}
+     */
+    copy() {
+        const clone = {
+            map: this.map,
+            revMap: this.revMap,
+            pos: this.pos,
+            step: this.step,
+            transform: this.transform,
+            revTransform: this.revTransform,
+        };
+        return clone;
+    }
+}
+
+/**
+ * Node in the menu graph
+ *
+ * A node represents a cipher/plaintext letter.
+ */
+class Node {
+    /**
+     * Node constructor.
+     * @param {number} letter - The plain/ciphertext letter this node represents (as a number).
+     */
+    constructor(letter) {
+        this.letter = letter;
+        this.edges = new Set();
+        this.visited = false;
+    }
+}
+
+/**
+ * Edge in the menu graph
+ *
+ * An edge represents an Enigma machine transformation between two letters.
+ */
+class Edge {
+    /**
+     * Edge constructor - an Enigma machine mapping between letters
+     * @param {number} pos - The rotor position, relative to the beginning of the crib, at this edge
+     * @param {number} node1 - Letter at one end (as a number)
+     * @param {number} node2 - Letter at the other end
+     */
+    constructor(pos, node1, node2) {
+        this.pos = pos;
+        this.node1 = node1;
+        this.node2 = node2;
+        node1.edges.add(this);
+        node2.edges.add(this);
+        this.visited = false;
+    }
+
+    /**
+     * Given the node at one end of this edge, return the other end.
+     * @param node {number} - The node we have
+     * @returns {number}
+     */
+    getOther(node) {
+        return this.node1 === node ? this.node2 : this.node1;
+    }
+}
+
+/**
+ * As all the Bombe's rotors move in step, at any given point the vast majority of the scramblers
+ * in the machine share the majority of their state, which is hosted in this class.
+ */
+class SharedScrambler {
+    /**
+     * SharedScrambler constructor.
+     * @param {Object[]} rotors - List of rotors in the shared state _only_.
+     * @param {Object} reflector - The reflector in use.
+     */
+    constructor(rotors, reflector) {
+        this.lowerCache = new Array(26);
+        this.higherCache = new Array(26);
+        for (let i=0; i<26; i++) {
+            this.higherCache[i] = new Array(26);
+        }
+        this.changeRotors(rotors, reflector);
+    }
+
+    /**
+     * Replace the rotors and reflector in this SharedScrambler.
+     * This takes care of flushing caches as well.
+     * @param {Object[]} rotors - List of rotors in the shared state _only_.
+     * @param {Object} reflector - The reflector in use.
+     */
+    changeRotors(rotors, reflector) {
+        this.reflector = reflector;
+        this.rotors = rotors;
+        this.rotorsRev = [].concat(rotors).reverse();
+        this.cacheGen();
+    }
+
+    /**
+     * Step the rotors forward.
+     * @param {number} n - How many rotors to step. This includes the rotors which are not part of
+     * the shared state, so should be 2 or more.
+     */
+    step(n) {
+        for (let i=0; i<n-1; i++) {
+            this.rotors[i].step();
+        }
+        this.cacheGen();
+    }
+
+    /**
+     * Optimisation: We pregenerate all routes through the machine with the top rotor removed,
+     * as these rarely change. This saves a lot of lookups. This function generates this route
+     * table.
+     * We also just-in-time cache the full routes through the scramblers, because after stepping
+     * the fast rotor some scramblers will be in states occupied by other scrambles on previous
+     * iterations.
+     */
+    cacheGen() {
+        for (let i=0; i<26; i++) {
+            this.lowerCache[i] = undefined;
+            for (let j=0; j<26; j++) {
+                this.higherCache[i][j] = undefined;
+            }
+        }
+        for (let i=0; i<26; i++) {
+            if (this.lowerCache[i] !== undefined) {
+                continue;
+            }
+            let letter = i;
+            for (const rotor of this.rotors) {
+                letter = rotor.transform(letter);
+            }
+            letter = this.reflector.transform(letter);
+            for (const rotor of this.rotorsRev) {
+                letter = rotor.revTransform(letter);
+            }
+            // By symmetry
+            this.lowerCache[i] = letter;
+            this.lowerCache[letter] = i;
+        }
+    }
+
+    /**
+     * Map a letter through this (partial) scrambler.
+     * @param {number} i - The letter
+     * @returns {number}
+     */
+    transform(i) {
+        return this.lowerCache[i];
+    }
+}
+
+/**
+ * Scrambler.
+ *
+ * This is effectively just an Enigma machine, but it only operates on one character at a time and
+ * the stepping mechanism is different.
+ */
+class Scrambler {
+    /** Scrambler constructor.
+     * @param {Object} base - The SharedScrambler whose state this scrambler uses
+     * @param {Object} rotor - The non-shared fast rotor in this scrambler
+     * @param {number} pos - Position offset from start of crib
+     * @param {number} end1 - Letter in menu this scrambler is attached to
+     * @param {number} end2 - Other letter in menu this scrambler is attached to
+     */
+    constructor(base, rotor, pos, end1, end2) {
+        this.baseScrambler = base;
+        this.initialPos = pos;
+        this.changeRotor(rotor);
+        this.end1 = end1;
+        this.end2 = end2;
+        // For efficiency reasons, we pull the relevant shared cache from the baseScrambler into
+        // this object - this saves us a few pointer dereferences
+        this.cache = this.baseScrambler.higherCache[pos];
+    }
+
+    /**
+     * Replace the rotor in this scrambler.
+     * The position is reset automatically.
+     * @param {Object} rotor - New rotor
+     */
+    changeRotor(rotor) {
+        this.rotor = rotor;
+        this.rotor.pos += this.initialPos;
+    }
+
+    /**
+     * Step the rotor forward.
+     *
+     * The base SharedScrambler needs to be instructed to step separately.
+     */
+    step() {
+        // The Bombe steps the slowest rotor on an actual Enigma fastest, for reasons.
+        // ...but for optimisation reasons I'm going to cheat and not do that, as this vastly
+        // simplifies caching the state of the majority of the scramblers. The results are the
+        // same, just in a slightly different order.
+        this.rotor.step();
+        this.cache = this.baseScrambler.higherCache[this.rotor.pos];
+    }
+
+
+    /**
+     * Run a letter through the scrambler.
+     * @param {number} i - The letter to transform (as a number)
+     * @returns {number}
+     */
+    transform(i) {
+        let letter = i;
+        const cached = this.cache[i];
+        if (cached !== undefined) {
+            return cached;
+        }
+        letter = this.rotor.transform(letter);
+        letter = this.baseScrambler.transform(letter);
+        letter = this.rotor.revTransform(letter);
+        this.cache[i] = letter;
+        this.cache[letter] = i;
+        return letter;
+    }
+
+    /**
+     * Given one letter in the menu this scrambler maps to, return the other.
+     * @param end {number} - The node we have
+     * @returns {number}
+     */
+    getOtherEnd(end) {
+        return this.end1 === end ? this.end2 : this.end1;
+    }
+
+    /**
+     * Read the position this scrambler is set to.
+     * Note that because of Enigma's stepping, you need to set an actual Enigma to the previous
+     * position in order to get it to make a certain set of electrical connections when a button
+     * is pressed - this function *does* take this into account.
+     * However, as with the rest of the Bombe, it does not take stepping into account - the middle
+     * and slow rotors are treated as static.
+     * @return {string}
+     */
+    getPos() {
+        let result = "";
+        // Roll back the fast rotor by one step
+        let pos = Utils.mod(this.rotor.pos - 1, 26);
+        result += i2a(pos);
+        for (let i=0; i<this.baseScrambler.rotors.length; i++) {
+            pos = this.baseScrambler.rotors[i].pos;
+            result += i2a(pos);
+        }
+        return result.split("").reverse().join("");
+    }
+}
+
+/**
+ * Bombe simulator class.
+ */
+export class BombeMachine {
+    /**
+     * Construct a Bombe.
+     *
+     * Note that there is no handling of offsets here: the crib specified must exactly match the
+     * ciphertext. It will check that the crib is sane (length is vaguely sensible and there's no
+     * matching characters between crib and ciphertext) but cannot check further - if it's wrong
+     * your results will be wrong!
+     *
+     * There is also no handling of rotor stepping - if the target Enigma stepped in the middle of
+     * your crib, you're out of luck. TODO: Allow specifying a step point - this is fairly easy to
+     * configure on a real Bombe, but we're not clear on whether it was ever actually done for
+     * real (there would almost certainly have been better ways of attacking in most situations
+     * than attempting to exhaust options for the stepping point, but in some circumstances, e.g.
+     * via Banburismus, the stepping point might have been known).
+     *
+     * @param {string[]} rotors - list of rotor spec strings (without step points!)
+     * @param {Object} reflector - Reflector object
+     * @param {string} ciphertext - The ciphertext to attack
+     * @param {string} crib - Known plaintext for this ciphertext
+     * @param {boolean} check - Whether to use the checking machine
+     * @param {function} update - Function to call to send status updates (optional)
+     */
+    constructor(rotors, reflector, ciphertext, crib, check, update=undefined) {
+        if (ciphertext.length < crib.length) {
+            throw new OperationError("Crib overruns supplied ciphertext");
+        }
+        if (crib.length < 2) {
+            // This is the absolute bare minimum to be sane, and even then it's likely too short to
+            // be useful
+            throw new OperationError("Crib is too short");
+        }
+        if (crib.length > 25) {
+            // A crib longer than this will definitely cause the middle rotor to step somewhere
+            // A shorter crib is preferable to reduce this chance, of course
+            throw new OperationError("Crib is too long");
+        }
+        for (let i=0; i<crib.length; i++) {
+            if (ciphertext[i] === crib[i]) {
+                throw new OperationError(`Invalid crib: character ${ciphertext[i]} at pos ${i} in both ciphertext and crib`);
+            }
+        }
+        this.ciphertext = ciphertext;
+        this.crib = crib;
+        this.initRotors(rotors);
+        this.check = check;
+        this.updateFn = update;
+
+        const [mostConnected, edges] = this.makeMenu();
+
+        // This is the bundle of wires corresponding to the 26 letters within each of the 26
+        // possible nodes in the menu
+        this.wires = new Array(26*26);
+
+        // These are the pseudo-Engima devices corresponding to each edge in the menu, and the
+        // nodes in the menu they each connect to
+        this.scramblers = new Array();
+        for (let i=0; i<26; i++) {
+            this.scramblers.push(new Array());
+        }
+        this.sharedScrambler = new SharedScrambler(this.baseRotors.slice(1), reflector);
+        this.allScramblers = new Array();
+        this.indicator = undefined;
+        for (const edge of edges) {
+            const cRotor = this.baseRotors[0].copy();
+            const end1 = a2i(edge.node1.letter);
+            const end2 = a2i(edge.node2.letter);
+            const scrambler = new Scrambler(this.sharedScrambler, cRotor, edge.pos, end1, end2);
+            if (edge.pos === 0) {
+                this.indicator = scrambler;
+            }
+            this.scramblers[end1].push(scrambler);
+            this.scramblers[end2].push(scrambler);
+            this.allScramblers.push(scrambler);
+        }
+        // The Bombe uses a set of rotors to keep track of what settings it's testing. We cheat and
+        // use one of the actual scramblers if there's one in the right position, but if not we'll
+        // just create one.
+        if (this.indicator === undefined) {
+            this.indicator = new Scrambler(this.sharedScrambler, this.baseRotors[0].copy(), 0, undefined, undefined);
+            this.allScramblers.push(this.indicator);
+        }
+
+        this.testRegister = a2i(mostConnected.letter);
+        // This is an arbitrary letter other than the most connected letter
+        for (const edge of mostConnected.edges) {
+            this.testInput = [this.testRegister, a2i(edge.getOther(mostConnected).letter)];
+            break;
+        }
+    }
+
+    /**
+     * Build Rotor objects from list of rotor wiring strings.
+     * @param {string[]} rotors - List of rotor wiring strings
+     */
+    initRotors(rotors) {
+        // This is ordered from the Enigma fast rotor to the slow, so bottom to top for the Bombe
+        this.baseRotors = [];
+        for (const rstr of rotors) {
+            const rotor = new CopyRotor(rstr, "", "A", "A");
+            this.baseRotors.push(rotor);
+        }
+    }
+
+    /**
+     * Replace the rotors and reflector in all components of this Bombe.
+     * @param {string[]} rotors - List of rotor wiring strings
+     * @param {Object} reflector - Reflector object
+     */
+    changeRotors(rotors, reflector) {
+        // At the end of the run, the rotors are all back in the same position they started
+        this.initRotors(rotors);
+        this.sharedScrambler.changeRotors(this.baseRotors.slice(1), reflector);
+        for (const scrambler of this.allScramblers) {
+            scrambler.changeRotor(this.baseRotors[0].copy());
+        }
+    }
+
+    /**
+     * If we have a way of sending status messages, do so.
+     * @param {...*} msg - Message to send.
+     */
+    update(...msg) {
+        if (this.updateFn !== undefined) {
+            this.updateFn(...msg);
+        }
+    }
+
+    /**
+     * Recursive depth-first search on the menu graph.
+     * This is used to a) isolate unconnected sub-graphs, and b) count the number of loops in each
+     * of those graphs.
+     * @param {Object} node - Node object to start the search from
+     * @returns {[number, number, Object, number, Object[]} - loop count, node count, most connected
+     *      node, order of most connected node, list of edges in this sub-graph
+     */
+    dfs(node) {
+        let loops = 0;
+        let nNodes = 1;
+        let mostConnected = node;
+        let nConnections = mostConnected.edges.size;
+        let edges = new Set();
+        node.visited = true;
+        for (const edge of node.edges) {
+            if (edge.visited) {
+                // Already been here from the other end.
+                continue;
+            }
+            edge.visited = true;
+            edges.add(edge);
+            const other = edge.getOther(node);
+            if (other.visited) {
+                // We have a loop, record that and continue
+                loops += 1;
+                continue;
+            }
+            // This is a newly visited node
+            const [oLoops, oNNodes, oMostConnected, oNConnections, oEdges] = this.dfs(other);
+            loops += oLoops;
+            nNodes += oNNodes;
+            edges = new Set([...edges, ...oEdges]);
+            if (oNConnections > nConnections) {
+                mostConnected = oMostConnected;
+                nConnections = oNConnections;
+            }
+        }
+        return [loops, nNodes, mostConnected, nConnections, edges];
+    }
+
+    /**
+     * Build a menu from the ciphertext and crib.
+     * A menu is just a graph where letters in either the ciphertext or crib (Enigma is symmetric,
+     * so there's no difference mathematically) are nodes and states of the Enigma machine itself
+     * are the edges.
+     * Additionally, we want a single connected graph, and of the subgraphs available, we want the
+     * one with the most loops (since these generate feedback cycles which efficiently close off
+     * disallowed states).
+     * Finally, we want to identify the most connected node in that graph (as it's the best choice
+     * of measurement point).
+     * @returns [Object, Object[]] - the most connected node, and the list of edges in the subgraph
+     */
+    makeMenu() {
+        // First, we make a graph of all of the mappings given by the crib
+        // Make all nodes first
+        const nodes = new Map();
+        for (const c of this.ciphertext + this.crib) {
+            if (!nodes.has(c)) {
+                const node = new Node(c);
+                nodes.set(c, node);
+            }
+        }
+        // Then all edges
+        for (let i=0; i<this.crib.length; i++) {
+            const a = this.crib[i];
+            const b = this.ciphertext[i];
+            new Edge(i, nodes.get(a), nodes.get(b));
+        }
+        // list of [loop_count, node_count, most_connected_node, connections_on_most_connected, edges]
+        const graphs = [];
+        // Then, for each unconnected subgraph, we count the number of loops and nodes
+        for (const start of nodes.keys()) {
+            if (nodes.get(start).visited) {
+                continue;
+            }
+            const subgraph = this.dfs(nodes.get(start));
+            graphs.push(subgraph);
+        }
+        // Return the subgraph with the most loops (ties broken by node count)
+        graphs.sort((a, b) => {
+            let result = b[0] - a[0];
+            if (result === 0) {
+                result = b[1] - a[1];
+            }
+            return result;
+        });
+        this.nLoops = graphs[0][0];
+        return [graphs[0][2], graphs[0][4]];
+    }
+
+    /**
+     * Bombe electrical simulation. Energise a wire. For all connected wires (both via the diagonal
+     * board and via the scramblers), energise them too, recursively.
+     * @param {number} i - Bombe wire bundle
+     * @param {number} j - Bombe stecker hypothesis wire within bundle
+     */
+    energise(i, j) {
+        const idx = 26*i + j;
+        if (this.wires[idx]) {
+            return;
+        }
+        this.wires[idx] = true;
+        // Welchman's diagonal board: if A steckers to B, that implies B steckers to A. Handle
+        // both.
+        const idxPair = 26*j + i;
+        this.wires[idxPair] = true;
+        if (i === this.testRegister || j === this.testRegister) {
+            this.energiseCount++;
+            if (this.energiseCount === 26) {
+                // no point continuing, bail out
+                return;
+            }
+        }
+
+        for (let k=0; k<this.scramblers[i].length; k++) {
+            const scrambler = this.scramblers[i][k];
+            const out = scrambler.transform(j);
+            const other = scrambler.getOtherEnd(i);
+            // Lift the pre-check before the call, to save some function call overhead
+            const otherIdx = 26*other + out;
+            if (!this.wires[otherIdx]) {
+                this.energise(other, out);
+                if (this.energiseCount === 26) {
+                    return;
+                }
+            }
+        }
+        if (i === j) {
+            return;
+        }
+        for (let k=0; k<this.scramblers[j].length; k++) {
+            const scrambler = this.scramblers[j][k];
+            const out = scrambler.transform(i);
+            const other = scrambler.getOtherEnd(j);
+            const otherIdx = 26*other + out;
+            if (!this.wires[otherIdx]) {
+                this.energise(other, out);
+                if (this.energiseCount === 26) {
+                    return;
+                }
+            }
+        }
+    }
+
+    /**
+     * Trial decryption at the current setting.
+     * Used after we get a stop.
+     * This applies the detected stecker pair if we have one. It does not handle the other
+     * steckering or stepping (which is why we limit it to 26 characters, since it's guaranteed to
+     * be wrong after that anyway).
+     * @param {string} stecker - Known stecker spec string.
+     * @returns {string}
+     */
+    tryDecrypt(stecker) {
+        const fastRotor = this.indicator.rotor;
+        const initialPos = fastRotor.pos;
+        const res = [];
+        const plugboard = new Plugboard(stecker);
+        // The indicator scrambler starts in the right place for the beginning of the ciphertext.
+        for (let i=0; i<Math.min(26, this.ciphertext.length); i++) {
+            const t = this.indicator.transform(plugboard.transform(a2i(this.ciphertext[i])));
+            res.push(i2a(plugboard.transform(t)));
+            this.indicator.step(1);
+        }
+        fastRotor.pos = initialPos;
+        return res.join("");
+    }
+
+    /**
+     * Format a steckered pair, in sorted order to allow uniquing.
+     * @param {number} a - A letter
+     * @param {number} b - Its stecker pair
+     * @returns {string}
+     */
+    formatPair(a, b) {
+        if (a < b) {
+            return `${i2a(a)}${i2a(b)}`;
+        }
+        return `${i2a(b)}${i2a(a)}`;
+    }
+
+    /**
+     * The checking machine was used to manually verify Bombe stops. Using a device which was
+     * effectively a non-stepping Enigma, the user would walk through each of the links in the
+     * menu at the rotor positions determined by the Bombe. By starting with the stecker pair the
+     * Bombe gives us, we find the stecker pair of each connected letter in the graph, and so on.
+     * If a contradiction is reached, the stop is invalid. If not, we have most (but not
+     * necessarily all) of the plugboard connections.
+     * You will notice that this procedure is exactly the same as what the Bombe itself does, only
+     * we start with an assumed good hypothesis and read out the stecker pair for every letter.
+     * On the real hardware that wasn't practical, but fortunately we're not the real hardware, so
+     * we don't need to implement the manual checking machine procedure.
+     * @param {number} pair - The stecker pair of the test register.
+     * @returns {string} - The empty string for invalid stops, or a plugboard configuration string
+     *      containing all known pairs.
+     */
+    checkingMachine(pair) {
+        if (pair !== this.testInput[1]) {
+            // We have a new hypothesis for this stop - apply the new one.
+            // De-energise the board
+            for (let i=0; i<this.wires.length; i++) {
+                this.wires[i] = false;
+            }
+            this.energiseCount = 0;
+            // Re-energise with the corrected hypothesis
+            this.energise(this.testRegister, pair);
+        }
+
+        const results = new Set();
+        results.add(this.formatPair(this.testRegister, pair));
+        for (let i=0; i<26; i++) {
+            let count = 0;
+            let other;
+            for (let j=0; j<26; j++) {
+                if (this.wires[i*26 + j]) {
+                    count++;
+                    other = j;
+                }
+            }
+            if (count > 1) {
+                // This is an invalid stop.
+                return "";
+            } else if (count === 0) {
+                // No information about steckering from this wire
+                continue;
+            }
+            results.add(this.formatPair(i, other));
+        }
+        return [...results].join(" ");
+    }
+
+    /**
+     * Check to see if the Bombe has stopped. If so, process the stop.
+     * @returns {(undefined|string[3])} - Undefined for no stop, or [rotor settings, plugboard settings, decryption preview]
+     */
+    checkStop() {
+        // Count the energised outputs
+        const count = this.energiseCount;
+        if (count === 26) {
+            return undefined;
+        }
+        // If it's not all of them, we have a stop
+        let steckerPair;
+        // The Bombe tells us one stecker pair as well. The input wire and test register we
+        // started with are hypothesised to be a stecker pair.
+        if (count === 25) {
+            // Our steckering hypothesis is wrong. Correct value is the un-energised wire.
+            for (let j=0; j<26; j++) {
+                if (!this.wires[26*this.testRegister + j]) {
+                    steckerPair = j;
+                    break;
+                }
+            }
+        } else if (count === 1) {
+            // This means our hypothesis for the steckering is correct.
+            steckerPair = this.testInput[1];
+        } else {
+            // This was known as a "boxing stop" - we have a stop but not a single hypothesis.
+            // If this happens a lot it implies the menu isn't good enough.
+            // If we have the checking machine enabled, we're going to just check each wire in
+            // turn. If we get 0 or 1 hit, great.
+            // If we get multiple hits, or the checking machine is off, the user will just have to
+            // deal with it.
+            if (!this.check) {
+                // We can't draw any conclusions about the steckering (one could maybe suggest
+                // options in some cases, but too hard to present clearly).
+                return [this.indicator.getPos(), "??", this.tryDecrypt("")];
+            }
+            let stecker = undefined;
+            for (let i = 0; i < 26; i++) {
+                const newStecker = this.checkingMachine(i);
+                if (newStecker !== "") {
+                    if (stecker !== undefined) {
+                        // Multiple hypotheses can't be ruled out.
+                        return [this.indicator.getPos(), "??", this.tryDecrypt("")];
+                    }
+                    stecker = newStecker;
+                }
+            }
+            if (stecker === undefined) {
+                // Checking machine ruled all possibilities out.
+                return undefined;
+            }
+            // If we got here, there was just one possibility allowed by the checking machine. Success.
+            return [this.indicator.getPos(), stecker, this.tryDecrypt(stecker)];
+        }
+        let stecker;
+        if (this.check) {
+            stecker = this.checkingMachine(steckerPair);
+            if (stecker === "") {
+                // Invalid stop - don't count it, don't return it
+                return undefined;
+            }
+        } else {
+            stecker = `${i2a(this.testRegister)}${i2a(steckerPair)}`;
+        }
+        const testDecrypt = this.tryDecrypt(stecker);
+        return [this.indicator.getPos(), stecker, testDecrypt];
+    }
+
+    /**
+     * Having set up the Bombe, do the actual attack run. This tries every possible rotor setting
+     * and attempts to logically invalidate them. If it can't, it's added to the list of candidate
+     * solutions.
+     * @returns {string[][3]} - list of 3-tuples of candidate rotor setting, plugboard settings, and decryption preview
+     */
+    run() {
+        let stops = 0;
+        const result = [];
+        // For each possible rotor setting
+        const nChecks = Math.pow(26, this.baseRotors.length);
+        for (let i=1; i<=nChecks; i++) {
+            // Benchmarking suggests this is faster than using .fill()
+            for (let i=0; i<this.wires.length; i++) {
+                this.wires[i] = false;
+            }
+            this.energiseCount = 0;
+            // Energise the test input, follow the current through each scrambler
+            // (and the diagonal board)
+            this.energise(...this.testInput);
+
+            const stop = this.checkStop();
+            if (stop !== undefined) {
+                stops++;
+                result.push(stop);
+            }
+            // Step all the scramblers
+            // This loop counts how many rotors have reached their starting position (meaning the
+            // next one needs to step as well)
+            let n = 1;
+            for (let j=1; j<this.baseRotors.length; j++) {
+                if ((i % Math.pow(26, j)) === 0) {
+                    n++;
+                } else {
+                    break;
+                }
+            }
+            if (n > 1) {
+                this.sharedScrambler.step(n);
+            }
+            for (const scrambler of this.allScramblers) {
+                scrambler.step();
+            }
+            // Send status messages at what seems to be a reasonably sensible frequency
+            // (note this won't be triggered on 3-rotor runs - they run fast enough it doesn't seem necessary)
+            if (n > 3) {
+                this.update(this.nLoops, stops, i/nChecks);
+            }
+        }
+        return result;
+    }
+}

src/core/lib/Enigma.mjs

@@ -0,0 +1,369 @@
+/**
+ * Emulation of the Enigma machine.
+ *
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import OperationError from "../errors/OperationError";
+import Utils from "../Utils";
+
+/**
+ * Provided default Enigma rotor set.
+ * These are specified as a list of mappings from the letters A through Z in order, optionally
+ * followed by < and a list of letters at which the rotor steps.
+ */
+export const ROTORS = [
+    {name: "I", value: "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R"},
+    {name: "II", value: "AJDKSIRUXBLHWTMCQGZNPYFVOE<F"},
+    {name: "III", value: "BDFHJLCPRTXVZNYEIWGAKMUSQO<W"},
+    {name: "IV", value: "ESOVPZJAYQUIRHXLNFTGKDCMWB<K"},
+    {name: "V", value: "VZBRGITYUPSDNHLXAWMJQOFECK<A"},
+    {name: "VI", value: "JPGVOUMFYQBENHZRDKASXLICTW<AN"},
+    {name: "VII", value: "NZJHGRCXMYSWBOUFAIVLPEKQDT<AN"},
+    {name: "VIII", value: "FKQHTLXOCBJSPDZRAMEWNIUYGV<AN"},
+];
+
+export const ROTORS_FOURTH = [
+    {name: "Beta", value: "LEYJVCNIXWPBQMDRTAKZGFUHOS"},
+    {name: "Gamma", value: "FSOKANUERHMBTIYCWLQPZXVGJD"},
+];
+
+/**
+ * Provided default Enigma reflector set.
+ * These are specified as 13 space-separated transposed pairs covering every letter.
+ */
+export const REFLECTORS = [
+    {name: "B", value: "AY BR CU DH EQ FS GL IP JX KN MO TZ VW"},
+    {name: "C", value: "AF BV CP DJ EI GO HY KR LZ MX NW TQ SU"},
+    {name: "B Thin", value: "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV"},
+    {name: "C Thin", value: "AR BD CO EJ FN GT HK IV LM PW QZ SX UY"},
+];
+
+export const LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".split("");
+
+/**
+ * Map a letter to a number in 0..25.
+ *
+ * @param {char} c
+ * @param {boolean} permissive - Case insensitive; don't throw errors on other chars.
+ * @returns {number}
+ */
+export function a2i(c, permissive=false) {
+    const i = Utils.ord(c);
+    if (i >= 65 && i <= 90) {
+        return i - 65;
+    }
+    if (permissive) {
+        // Allow case insensitivity
+        if (i >= 97 && i <= 122) {
+            return i - 97;
+        }
+        return -1;
+    }
+    throw new OperationError("a2i called on non-uppercase ASCII character");
+}
+
+/**
+ * Map a number in 0..25 to a letter.
+ *
+ * @param {number} i
+ * @returns {char}
+ */
+export function i2a(i) {
+    if (i >= 0 && i < 26) {
+        return Utils.chr(i+65);
+    }
+    throw new OperationError("i2a called on value outside 0..25");
+}
+
+/**
+ * A rotor in the Enigma machine.
+ */
+export class Rotor {
+    /**
+     * Rotor constructor.
+     *
+     * @param {string} wiring - A 26 character string of the wiring order.
+     * @param {string} steps - A 0..26 character string of stepping points.
+     * @param {char} ringSetting - The ring setting.
+     * @param {char} initialPosition - The initial position of the rotor.
+     */
+    constructor(wiring, steps, ringSetting, initialPosition) {
+        if (!/^[A-Z]{26}$/.test(wiring)) {
+            throw new OperationError("Rotor wiring must be 26 unique uppercase letters");
+        }
+        if (!/^[A-Z]{0,26}$/.test(steps)) {
+            throw new OperationError("Rotor steps must be 0-26 unique uppercase letters");
+        }
+        if (!/^[A-Z]$/.test(ringSetting)) {
+            throw new OperationError("Rotor ring setting must be exactly one uppercase letter");
+        }
+        if (!/^[A-Z]$/.test(initialPosition)) {
+            throw new OperationError("Rotor initial position must be exactly one uppercase letter");
+        }
+        this.map = new Array(26);
+        this.revMap = new Array(26);
+        const uniq = {};
+        for (let i=0; i<LETTERS.length; i++) {
+            const a = a2i(LETTERS[i]);
+            const b = a2i(wiring[i]);
+            this.map[a] = b;
+            this.revMap[b] = a;
+            uniq[b] = true;
+        }
+        if (Object.keys(uniq).length !== LETTERS.length) {
+            throw new OperationError("Rotor wiring must have each letter exactly once");
+        }
+        const rs = a2i(ringSetting);
+        this.steps = new Set();
+        for (const x of steps) {
+            this.steps.add(Utils.mod(a2i(x) - rs, 26));
+        }
+        if (this.steps.size !== steps.length) {
+            // This isn't strictly fatal, but it's probably a mistake
+            throw new OperationError("Rotor steps must be unique");
+        }
+        this.pos = Utils.mod(a2i(initialPosition) - rs, 26);
+    }
+
+    /**
+     * Step the rotor forward by one.
+     */
+    step() {
+        this.pos = Utils.mod(this.pos + 1, 26);
+        return this.pos;
+    }
+
+    /**
+     * Transform a character through this rotor forwards.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    transform(c) {
+        return Utils.mod(this.map[Utils.mod(c + this.pos, 26)] - this.pos, 26);
+    }
+
+    /**
+     * Transform a character through this rotor backwards.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    revTransform(c) {
+        return Utils.mod(this.revMap[Utils.mod(c + this.pos, 26)] - this.pos, 26);
+    }
+}
+
+/**
+ * Base class for plugboard and reflector (since these do effectively the same
+ * thing).
+ */
+class PairMapBase {
+    /**
+     * PairMapBase constructor.
+     *
+     * @param {string} pairs - A whitespace separated string of letter pairs to swap.
+     * @param {string} [name='PairMapBase'] - For errors, the name of this object.
+     */
+    constructor(pairs, name="PairMapBase") {
+        // I've chosen to make whitespace significant here to make a) code and
+        // b) inputs easier to read
+        this.pairs = pairs;
+        this.map = {};
+        if (pairs === "") {
+            return;
+        }
+        pairs.split(/\s+/).forEach(pair => {
+            if (!/^[A-Z]{2}$/.test(pair)) {
+                throw new OperationError(name + " must be a whitespace-separated list of uppercase letter pairs");
+            }
+            const a = a2i(pair[0]), b = a2i(pair[1]);
+            if (a === b) {
+                // self-stecker
+                return;
+            }
+            if (this.map.hasOwnProperty(a)) {
+                throw new OperationError(`${name} connects ${pair[0]} more than once`);
+            }
+            if (this.map.hasOwnProperty(b)) {
+                throw new OperationError(`${name} connects ${pair[1]} more than once`);
+            }
+            this.map[a] = b;
+            this.map[b] = a;
+        });
+    }
+
+    /**
+     * Transform a character through this object.
+     * Returns other characters unchanged.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    transform(c) {
+        if (!this.map.hasOwnProperty(c)) {
+            return c;
+        }
+        return this.map[c];
+    }
+
+    /**
+     * Alias for transform, to allow interchangeable use with rotors.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    revTransform(c) {
+        return this.transform(c);
+    }
+}
+
+/**
+ * Reflector. PairMapBase but requires that all characters are accounted for.
+ *
+ * Includes a couple of optimisations on that basis.
+ */
+export class Reflector extends PairMapBase {
+    /**
+     * Reflector constructor. See PairMapBase.
+     * Additional restriction: every character must be accounted for.
+     */
+    constructor(pairs) {
+        super(pairs, "Reflector");
+        const s = Object.keys(this.map).length;
+        if (s !== 26) {
+            throw new OperationError("Reflector must have exactly 13 pairs covering every letter");
+        }
+        const optMap = new Array(26);
+        for (const x of Object.keys(this.map)) {
+            optMap[x] = this.map[x];
+        }
+        this.map = optMap;
+    }
+
+    /**
+     * Transform a character through this object.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    transform(c) {
+        return this.map[c];
+    }
+}
+
+/**
+ * Plugboard. Unmodified PairMapBase.
+ */
+export class Plugboard extends PairMapBase {
+    /**
+     * Plugboard constructor. See PairMapbase.
+     */
+    constructor(pairs) {
+        super(pairs, "Plugboard");
+    }
+}
+
+/**
+ * Base class for the Enigma machine itself. Holds rotors, a reflector, and a plugboard.
+ */
+export class EnigmaBase {
+    /**
+     * EnigmaBase constructor.
+     *
+     * @param {Object[]} rotors - List of Rotors.
+     * @param {Object} reflector - A Reflector.
+     * @param {Plugboard} plugboard - A Plugboard.
+     */
+    constructor(rotors, reflector, plugboard) {
+        this.rotors = rotors;
+        this.rotorsRev = [].concat(rotors).reverse();
+        this.reflector = reflector;
+        this.plugboard = plugboard;
+    }
+
+    /**
+     * Step the rotors forward by one.
+     *
+     * This happens before the output character is generated.
+     *
+     * Note that rotor 4, if it's there, never steps.
+     *
+     * Why is all the logic in EnigmaBase and not a nice neat method on
+     * Rotor that knows when it should advance the next item?
+     * Because the double stepping anomaly is a thing. tl;dr if the left rotor
+     * should step the next time the middle rotor steps, the middle rotor will
+     * immediately step.
+     */
+    step() {
+        const r0 = this.rotors[0];
+        const r1 = this.rotors[1];
+        r0.step();
+        // The second test here is the double-stepping anomaly
+        if (r0.steps.has(r0.pos) || r1.steps.has(Utils.mod(r1.pos + 1, 26))) {
+            r1.step();
+            if (r1.steps.has(r1.pos)) {
+                const r2 = this.rotors[2];
+                r2.step();
+            }
+        }
+    }
+
+    /**
+     * Encrypt (or decrypt) some data.
+     * Takes an arbitrary string and runs the Engima machine on that data from
+     * *its current state*, and outputs the result. Non-alphabetic characters
+     * are returned unchanged.
+     *
+     * @param {string} input - Data to encrypt.
+     * @returns {string}
+     */
+    crypt(input) {
+        let result = "";
+        for (const c of input) {
+            let letter = a2i(c, true);
+            if (letter === -1) {
+                result += c;
+                continue;
+            }
+            // First, step the rotors forward.
+            this.step();
+            // Now, run through the plugboard.
+            letter = this.plugboard.transform(letter);
+            // Then through each wheel in sequence, through the reflector, and
+            // backwards through the wheels again.
+            for (const rotor of this.rotors) {
+                letter = rotor.transform(letter);
+            }
+            letter = this.reflector.transform(letter);
+            for (const rotor of this.rotorsRev) {
+                letter = rotor.revTransform(letter);
+            }
+            // Finally, back through the plugboard.
+            letter = this.plugboard.revTransform(letter);
+            result += i2a(letter);
+        }
+        return result;
+    }
+}
+
+/**
+ * The Enigma machine itself. Holds 3-4 rotors, a reflector, and a plugboard.
+ */
+export class EnigmaMachine extends EnigmaBase {
+    /**
+     * EnigmaMachine constructor.
+     *
+     * @param {Object[]} rotors - List of Rotors.
+     * @param {Object} reflector - A Reflector.
+     * @param {Plugboard} plugboard - A Plugboard.
+     */
+    constructor(rotors, reflector, plugboard) {
+        super(rotors, reflector, plugboard);
+        if (rotors.length !== 3 && rotors.length !== 4) {
+            throw new OperationError("Enigma must have 3 or 4 rotors");
+        }
+    }
+}

src/core/lib/Typex.mjs

@@ -0,0 +1,227 @@
+/**
+ * Emulation of the Typex machine.
+ *
+ * @author s2224834
+ * @author The National Museum of Computing - Bombe Rebuild Project
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import OperationError from "../errors/OperationError";
+import * as Enigma from "../lib/Enigma";
+import Utils from "../Utils";
+
+/**
+ * A set of example Typex rotors. No Typex rotor wirings are publicly available, so these are
+ * randomised.
+ */
+export const ROTORS = [
+    {name: "Example 1", value: "MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW"},
+    {name: "Example 2", value: "KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW"},
+    {name: "Example 3", value: "BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW"},
+    {name: "Example 4", value: "ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW"},
+    {name: "Example 5", value: "QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW"},
+    {name: "Example 6", value: "BDCNWUEIQVFTSXALOGZJYMHKPR<BFHNQUW"},
+    {name: "Example 7", value: "WJUKEIABMSGFTQZVCNPHORDXYL<BFHNQUW"},
+    {name: "Example 8", value: "TNVCZXDIPFWQKHSJMAOYLEURGB<BFHNQUW"},
+];
+
+/**
+ * An example Typex reflector. Again, randomised.
+ */
+export const REFLECTORS = [
+    {name: "Example", value: "AN BC FG IE KD LU MH OR TS VZ WQ XJ YP"},
+];
+
+// Special character handling on Typex keyboard
+const KEYBOARD = {
+    "Q": "1", "W": "2", "E": "3", "R": "4", "T": "5", "Y": "6", "U": "7", "I": "8", "O": "9", "P": "0",
+    "A": "-", "S": "/", "D": "Z", "F": "%", "G": "X", "H": "£", "K": "(", "L": ")",
+    "C": "V", "B": "'", "N": ",", "M": "."
+};
+const KEYBOARD_REV = {};
+for (const i of Object.keys(KEYBOARD)) {
+    KEYBOARD_REV[KEYBOARD[i]] = i;
+}
+
+/**
+ * Typex machine. A lot like the Enigma, but five rotors, of which the first two are static.
+ */
+export class TypexMachine extends Enigma.EnigmaBase {
+    /**
+     * TypexMachine constructor.
+     *
+     * @param {Object[]} rotors - List of Rotors.
+     * @param {Object} reflector - A Reflector.
+     * @param {Plugboard} plugboard - A Plugboard.
+     */
+    constructor(rotors, reflector, plugboard, keyboard) {
+        super(rotors, reflector, plugboard);
+        if (rotors.length !== 5) {
+            throw new OperationError("Typex must have 5 rotors");
+        }
+        this.keyboard = keyboard;
+    }
+
+    /**
+     * This is the same as the Enigma step function, it's just that the right-
+     * most two rotors are static.
+     */
+    step() {
+        const r0 = this.rotors[2];
+        const r1 = this.rotors[3];
+        r0.step();
+        // The second test here is the double-stepping anomaly
+        if (r0.steps.has(r0.pos) || r1.steps.has(Utils.mod(r1.pos + 1, 26))) {
+            r1.step();
+            if (r1.steps.has(r1.pos)) {
+                const r2 = this.rotors[4];
+                r2.step();
+            }
+        }
+    }
+
+    /**
+     * Encrypt/decrypt data. This is identical to the Enigma version cryptographically, but we have
+     * additional handling for the Typex's keyboard (which handles various special characters by
+     * mapping them to particular letter combinations).
+     *
+     * @param {string} input - The data to encrypt/decrypt.
+     * @return {string}
+     */
+    crypt(input) {
+        let inputMod = input;
+        if (this.keyboard === "Encrypt") {
+            inputMod = "";
+            // true = in symbol mode
+            let mode = false;
+            for (const x of input) {
+                if (x === " ") {
+                    inputMod += "X";
+                } else if (mode) {
+                    if (KEYBOARD_REV.hasOwnProperty(x)) {
+                        inputMod += KEYBOARD_REV[x];
+                    } else {
+                        mode = false;
+                        inputMod += "V" + x;
+                    }
+                } else {
+                    if (KEYBOARD_REV.hasOwnProperty(x)) {
+                        mode = true;
+                        inputMod += "Z" + KEYBOARD_REV[x];
+                    } else {
+                        inputMod += x;
+                    }
+                }
+            }
+        }
+
+        const output = super.crypt(inputMod);
+
+        let outputMod = output;
+        if (this.keyboard === "Decrypt") {
+            outputMod = "";
+            let mode = false;
+            for (const x of output) {
+                if (x === "X") {
+                    outputMod += " ";
+                } else if (x === "V") {
+                    mode = false;
+                } else if (x === "Z") {
+                    mode = true;
+                } else if (mode) {
+                    outputMod += KEYBOARD[x];
+                } else {
+                    outputMod += x;
+                }
+            }
+        }
+        return outputMod;
+    }
+}
+
+/**
+ * Typex rotor. Like an Enigma rotor, but no ring setting, and can be reversed.
+ */
+export class Rotor extends Enigma.Rotor {
+    /**
+     * Rotor constructor.
+     *
+     * @param {string} wiring - A 26 character string of the wiring order.
+     * @param {string} steps - A 0..26 character string of stepping points.
+     * @param {bool} reversed - Whether to reverse the rotor.
+     * @param {char} ringSetting - Ring setting of the rotor.
+     * @param {char} initialPosition - The initial position of the rotor.
+     */
+    constructor(wiring, steps, reversed, ringSetting, initialPos) {
+        let wiringMod = wiring;
+        if (reversed) {
+            const outMap = new Array(26);
+            for (let i=0; i<26; i++) {
+                // wiring[i] is the original output
+                // Enigma.LETTERS[i] is the original input
+                const input = Utils.mod(26 - Enigma.a2i(wiring[i]), 26);
+                const output = Enigma.i2a(Utils.mod(26 - Enigma.a2i(Enigma.LETTERS[i]), 26));
+                outMap[input] = output;
+            }
+            wiringMod = outMap.join("");
+        }
+        super(wiringMod, steps, ringSetting, initialPos);
+    }
+}
+
+/**
+ * Typex input plugboard. Based on a Rotor, because it allows arbitrary maps, not just switches
+ * like the Enigma plugboard.
+ * Not to be confused with the reflector plugboard.
+ * This is also where the Typex's backwards input wiring is implemented - it's a bit of a hack, but
+ * it means everything else continues to work like in the Enigma.
+ */
+export class Plugboard extends Enigma.Rotor {
+    /**
+     * Typex plugboard constructor.
+     *
+     * @param {string} wiring - 26 character string of mappings from A-Z, as per rotors, or "".
+     */
+    constructor(wiring) {
+        // Typex input wiring is backwards vs Enigma: that is, letters enter the rotors in a
+        // clockwise order, vs. Enigma's anticlockwise (or vice versa depending on which side
+        // you're looking at it from). I'm doing the transform here to avoid having to rewrite
+        // the Engima crypt() method in Typex as well.
+        // Note that the wiring for the reflector is the same way around as Enigma, so no
+        // transformation is necessary on that side.
+        // We're going to achieve this by mapping the plugboard settings through an additional
+        // transform that mirrors the alphabet before we pass it to the superclass.
+        if (!/^[A-Z]{26}$/.test(wiring)) {
+            throw new OperationError("Plugboard wiring must be 26 unique uppercase letters");
+        }
+        const reversed = "AZYXWVUTSRQPONMLKJIHGFEDCB";
+        wiring = wiring.replace(/./g, x => {
+            return reversed[Enigma.a2i(x)];
+        });
+        try {
+            super(wiring, "", "A", "A");
+        } catch (err) {
+            throw new OperationError(err.message.replace("Rotor", "Plugboard"));
+        }
+    }
+
+    /**
+     * Transform a character through this rotor forwards.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    transform(c) {
+        return Utils.mod(this.map[Utils.mod(c + this.pos, 26)] - this.pos, 26);
+    }
+
+    /**
+     * Transform a character through this rotor backwards.
+     *
+     * @param {number} c - The character.
+     * @returns {number}
+     */
+    revTransform(c) {
+        return Utils.mod(this.revMap[Utils.mod(c + this.pos, 26)] - this.pos, 26);
+    }
+}

src/core/operations/Enigma.mjs

@@ -0,0 +1,214 @@
+/**
+ * Emulation of the Enigma machine.
+ *
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import {ROTORS, LETTERS, ROTORS_FOURTH, REFLECTORS, Rotor, Reflector, Plugboard, EnigmaMachine} from "../lib/Enigma";
+
+/**
+ * Enigma operation
+ */
+class Enigma extends Operation {
+    /**
+     * Enigma constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Enigma";
+        this.module = "Default";
+        this.description = "Encipher/decipher with the WW2 Enigma machine.<br><br>Enigma was used by the German military, among others, around the WW2 era as a portable cipher machine to protect sensitive military, diplomatic and commercial communications.<br><br>The standard set of German military rotors and reflectors are provided. To configure the plugboard, enter a string of connected pairs of letters, e.g. <code>AB CD EF</code> connects A to B, C to D, and E to F. This is also used to create your own reflectors. To create your own rotor, enter the letters that the rotor maps A to Z to, in order, optionally followed by <code>&lt;</code> then a list of stepping points.<br>This is deliberately fairly permissive with rotor placements etc compared to a real Enigma (on which, for example, a four-rotor Enigma uses only the thin reflectors and the beta or gamma rotor in the 4th slot).<br><br>More detailed descriptions of the Enigma, Typex and Bombe operations <a href='https://github.com/gchq/CyberChef/wiki/Enigma,-the-Bombe,-and-Typex'>can be found here</a>.";
+        this.infoURL = "https://wikipedia.org/wiki/Enigma_machine";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Model",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "3-rotor",
+                        off: [1, 2, 3]
+                    },
+                    {
+                        name: "4-rotor",
+                        on: [1, 2, 3]
+                    }
+                ]
+            },
+            {
+                name: "Left-most (4th) rotor",
+                type: "editableOption",
+                value: ROTORS_FOURTH,
+                defaultIndex: 0
+            },
+            {
+                name: "Left-most rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Left-most rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Left-hand rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "Left-hand rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Left-hand rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Middle rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 1
+            },
+            {
+                name: "Middle rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Middle rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Right-hand rotor",
+                type: "editableOption",
+                value: ROTORS,
+                // Default config is the rotors I-III *left to right*
+                defaultIndex: 2
+            },
+            {
+                name: "Right-hand rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Right-hand rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Reflector",
+                type: "editableOption",
+                value: REFLECTORS
+            },
+            {
+                name: "Plugboard",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Strict output",
+                hint: "Remove non-alphabet letters and group output",
+                type: "boolean",
+                value: true
+            },
+        ];
+    }
+
+    /**
+     * Helper - for ease of use rotors are specified as a single string; this
+     * method breaks the spec string into wiring and steps parts.
+     *
+     * @param {string} rotor - Rotor specification string.
+     * @param {number} i - For error messages, the number of this rotor.
+     * @returns {string[]}
+     */
+    parseRotorStr(rotor, i) {
+        if (rotor === "") {
+            throw new OperationError(`Rotor ${i} must be provided.`);
+        }
+        if (!rotor.includes("<")) {
+            return [rotor, ""];
+        }
+        return rotor.split("<", 2);
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const model = args[0];
+        const reflectorstr = args[13];
+        const plugboardstr = args[14];
+        const removeOther = args[15];
+        const rotors = [];
+        for (let i=0; i<4; i++) {
+            if (i === 0 && model === "3-rotor") {
+                // Skip the 4th rotor settings
+                continue;
+            }
+            const [rotorwiring, rotorsteps] = this.parseRotorStr(args[i*3 + 1], 1);
+            rotors.push(new Rotor(rotorwiring, rotorsteps, args[i*3 + 2], args[i*3 + 3]));
+        }
+        // Rotors are handled in reverse
+        rotors.reverse();
+        const reflector = new Reflector(reflectorstr);
+        const plugboard = new Plugboard(plugboardstr);
+        if (removeOther) {
+            input = input.replace(/[^A-Za-z]/g, "");
+        }
+        const enigma = new EnigmaMachine(rotors, reflector, plugboard);
+        let result = enigma.crypt(input);
+        if (removeOther) {
+            // Five character cipher groups is traditional
+            result = result.replace(/([A-Z]{5})(?!$)/g, "$1 ");
+        }
+        return result;
+    }
+
+    /**
+     * Highlight Enigma
+     * This is only possible if we're passing through non-alphabet characters.
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlight(pos, args) {
+        if (args[13] === false) {
+            return pos;
+        }
+    }
+
+    /**
+     * Highlight Enigma in reverse
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlightReverse(pos, args) {
+        if (args[13] === false) {
+            return pos;
+        }
+    }
+
+}
+
+export default Enigma;

src/core/operations/MultipleBombe.mjs

@@ -0,0 +1,305 @@
+/**
+ * Emulation of the Bombe machine.
+ * This version carries out multiple Bombe runs to handle unknown rotor configurations.
+ *
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import {BombeMachine} from "../lib/Bombe";
+import {ROTORS, ROTORS_FOURTH, REFLECTORS, Reflector} from "../lib/Enigma";
+
+/**
+ * Convenience method for flattening the preset ROTORS object into a newline-separated string.
+ * @param {Object[]} - Preset rotors object
+ * @param {number} s - Start index
+ * @param {number} n - End index
+ * @returns {string}
+ */
+function rotorsFormat(rotors, s, n) {
+    const res = [];
+    for (const i of rotors.slice(s, n)) {
+        res.push(i.value);
+    }
+    return res.join("\n");
+}
+
+/**
+ * Combinatorics choose function
+ * @param {number} n
+ * @param {number} k
+ * @returns number
+ */
+function choose(n, k) {
+    let res = 1;
+    for (let i=1; i<=k; i++) {
+        res *= (n + 1 - i) / i;
+    }
+    return res;
+}
+
+/**
+ * Bombe operation
+ */
+class MultipleBombe extends Operation {
+    /**
+     * Bombe constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Multiple Bombe";
+        this.module = "Default";
+        this.description = "Emulation of the Bombe machine used to attack Enigma. This version carries out multiple Bombe runs to handle unknown rotor configurations.<br><br>You should test your menu on the single Bombe operation before running it here. See the description of the Bombe operation for instructions on choosing a crib.<br><br>More detailed descriptions of the Enigma, Typex and Bombe operations <a href='https://github.com/gchq/CyberChef/wiki/Enigma,-the-Bombe,-and-Typex'>can be found here</a>.";
+        this.infoURL = "https://wikipedia.org/wiki/Bombe";
+        this.inputType = "string";
+        this.outputType = "JSON";
+        this.presentType = "html";
+        this.args = [
+            {
+                "name": "Standard Enigmas",
+                "type": "populateMultiOption",
+                "value": [
+                    {
+                        name: "German Service Enigma (First - 3 rotor)",
+                        value: [
+                            rotorsFormat(ROTORS, 0, 5),
+                            "",
+                            rotorsFormat(REFLECTORS, 0, 1)
+                        ]
+                    },
+                    {
+                        name: "German Service Enigma (Second - 3 rotor)",
+                        value: [
+                            rotorsFormat(ROTORS, 0, 8),
+                            "",
+                            rotorsFormat(REFLECTORS, 0, 2)
+                        ]
+                    },
+                    {
+                        name: "German Service Enigma (Third - 4 rotor)",
+                        value: [
+                            rotorsFormat(ROTORS, 0, 8),
+                            rotorsFormat(ROTORS_FOURTH, 1, 2),
+                            rotorsFormat(REFLECTORS, 2, 3)
+                        ]
+                    },
+                    {
+                        name: "German Service Enigma (Fourth - 4 rotor)",
+                        value: [
+                            rotorsFormat(ROTORS, 0, 8),
+                            rotorsFormat(ROTORS_FOURTH, 1, 3),
+                            rotorsFormat(REFLECTORS, 2, 4)
+                        ]
+                    },
+                    {
+                        name: "User defined",
+                        value: ["", "", ""]
+                    },
+                ],
+                "target": [1, 2, 3]
+            },
+            {
+                name: "Main rotors",
+                type: "text",
+                value: ""
+            },
+            {
+                name: "4th rotor",
+                type: "text",
+                value: ""
+            },
+            {
+                name: "Reflectors",
+                type: "text",
+                value: ""
+            },
+            {
+                name: "Crib",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Crib offset",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Use checking machine",
+                type: "boolean",
+                value: true
+            }
+        ];
+    }
+
+    /**
+     * Format and send a status update message.
+     * @param {number} nLoops - Number of loops in the menu
+     * @param {number} nStops - How many stops so far
+     * @param {number} progress - Progress (as a float in the range 0..1)
+     */
+    updateStatus(nLoops, nStops, progress, start) {
+        const elapsed = new Date().getTime() - start;
+        const remaining = (elapsed / progress) * (1 - progress) / 1000;
+        const hours = Math.floor(remaining / 3600);
+        const minutes = `0${Math.floor((remaining % 3600) / 60)}`.slice(-2);
+        const seconds = `0${Math.floor(remaining % 60)}`.slice(-2);
+        const msg = `Bombe run with ${nLoops} loop${nLoops === 1 ? "" : "s"} in menu (2+ desirable): ${nStops} stops, ${Math.floor(100 * progress)}% done, ${hours}:${minutes}:${seconds} remaining`;
+        self.sendStatusMessage(msg);
+    }
+
+    /**
+     * Early rotor description string validation.
+     * Drops stepping information.
+     * @param {string} rstr - The rotor description string
+     * @returns {string} - Rotor description with stepping stripped, if any
+     */
+    validateRotor(rstr) {
+        // The Bombe doesn't take stepping into account so we'll just ignore it here
+        if (rstr.includes("<")) {
+            rstr = rstr.split("<", 2)[0];
+        }
+        // Duplicate the validation of the rotor strings here, otherwise you might get an error
+        // thrown halfway into a big Bombe run
+        if (!/^[A-Z]{26}$/.test(rstr)) {
+            throw new OperationError("Rotor wiring must be 26 unique uppercase letters");
+        }
+        if (new Set(rstr).size !== 26) {
+            throw new OperationError("Rotor wiring must be 26 unique uppercase letters");
+        }
+        return rstr;
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const mainRotorsStr = args[1];
+        const fourthRotorsStr = args[2];
+        const reflectorsStr = args[3];
+        let crib = args[4];
+        const offset = args[5];
+        const check = args[6];
+        const rotors = [];
+        const fourthRotors = [];
+        const reflectors = [];
+        for (let rstr of mainRotorsStr.split("\n")) {
+            rstr = this.validateRotor(rstr);
+            rotors.push(rstr);
+        }
+        if (rotors.length < 3) {
+            throw new OperationError("A minimum of three rotors must be supplied");
+        }
+        if (fourthRotorsStr !== "") {
+            for (let rstr of fourthRotorsStr.split("\n")) {
+                rstr = this.validateRotor(rstr);
+                fourthRotors.push(rstr);
+            }
+        }
+        if (fourthRotors.length === 0) {
+            fourthRotors.push("");
+        }
+        for (const rstr of reflectorsStr.split("\n")) {
+            const reflector = new Reflector(rstr);
+            reflectors.push(reflector);
+        }
+        if (reflectors.length === 0) {
+            throw new OperationError("A minimum of one reflector must be supplied");
+        }
+        if (crib.length === 0) {
+            throw new OperationError("Crib cannot be empty");
+        }
+        if (offset < 0) {
+            throw new OperationError("Offset cannot be negative");
+        }
+        // For symmetry with the Enigma op, for the input we'll just remove all invalid characters
+        input = input.replace(/[^A-Za-z]/g, "").toUpperCase();
+        crib = crib.replace(/[^A-Za-z]/g, "").toUpperCase();
+        const ciphertext = input.slice(offset);
+        let update;
+        if (ENVIRONMENT_IS_WORKER()) {
+            update = this.updateStatus;
+        } else {
+            update = undefined;
+        }
+        let bombe = undefined;
+        const output = {bombeRuns: []};
+        // I could use a proper combinatorics algorithm here... but it would be more code to
+        // write one, and we don't seem to have one in our existing libraries, so massively nested
+        // for loop it is
+        const totalRuns = choose(rotors.length, 3) * 6 * fourthRotors.length * reflectors.length;
+        let nRuns = 0;
+        let nStops = 0;
+        const start = new Date().getTime();
+        for (const rotor1 of rotors) {
+            for (const rotor2 of rotors) {
+                if (rotor2 === rotor1) {
+                    continue;
+                }
+                for (const rotor3 of rotors) {
+                    if (rotor3 === rotor2 || rotor3 === rotor1) {
+                        continue;
+                    }
+                    for (const rotor4 of fourthRotors) {
+                        for (const reflector of reflectors) {
+                            nRuns++;
+                            const runRotors = [rotor1, rotor2, rotor3];
+                            if (rotor4 !== "") {
+                                runRotors.push(rotor4);
+                            }
+                            if (bombe === undefined) {
+                                bombe = new BombeMachine(runRotors, reflector, ciphertext, crib, check);
+                                output.nLoops = bombe.nLoops;
+                            } else {
+                                bombe.changeRotors(runRotors, reflector);
+                            }
+                            const result = bombe.run();
+                            nStops += result.length;
+                            if (update !== undefined) {
+                                update(bombe.nLoops, nStops, nRuns / totalRuns, start);
+                            }
+                            if (result.length > 0) {
+                                output.bombeRuns.push({
+                                    rotors: runRotors,
+                                    reflector: reflector.pairs,
+                                    result: result
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return output;
+    }
+
+
+    /**
+     * Displays the MultiBombe results in an HTML table
+     *
+     * @param {Object} output
+     * @param {number} output.nLoops
+     * @param {Array[]} output.result
+     * @returns {html}
+     */
+    present(output) {
+        let html = `Bombe run on menu with ${output.nLoops} loop${output.nLoops === 1 ? "" : "s"} (2+ desirable). Note: Rotors and rotor positions are listed left to right, ignore stepping and the ring setting, and positions start at the beginning of the crib. Some plugboard settings are determined. A decryption preview starting at the beginning of the crib and ignoring stepping is also provided.\n`;
+
+        for (const run of output.bombeRuns) {
+            html += `\nRotors: ${run.rotors.slice().reverse().join(", ")}\nReflector: ${run.reflector}\n`;
+            html += "<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>Rotor stops</th>  <th>Partial plugboard</th>  <th>Decryption preview</th></tr>\n";
+            for (const [setting, stecker, decrypt] of run.result) {
+                html += `<tr><td>${setting}</td>  <td>${stecker}</td>  <td>${decrypt}</td></tr>\n`;
+            }
+            html += "</table>\n";
+        }
+        return html;
+    }
+}
+
+export default MultipleBombe;

src/core/operations/Typex.mjs

@@ -0,0 +1,250 @@
+/**
+ * Emulation of the Typex machine.
+ *
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import {LETTERS, Reflector} from "../lib/Enigma";
+import {ROTORS, REFLECTORS, TypexMachine, Plugboard, Rotor} from "../lib/Typex";
+
+/**
+ * Typex operation
+ */
+class Typex extends Operation {
+    /**
+     * Typex constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Typex";
+        this.module = "Default";
+        this.description = "Encipher/decipher with the WW2 Typex machine.<br><br>Typex was originally built by the British Royal Air Force prior to WW2, and is based on the Enigma machine with some improvements made, including using five rotors with more stepping points and interchangeable wiring cores. It was used across the British and Commonewealth militaries. A number of later variants were produced; here we simulate a WW2 era Mark 22 Typex with plugboards for the reflector and input. Typex rotors were changed regularly and none are public: a random example set are provided.<br><br>To configure the reflector plugboard, enter a string of connected pairs of letters in the reflector box, e.g. <code>AB CD EF</code> connects A to B, C to D, and E to F (you'll need to connect every letter). There is also an input plugboard: unlike Enigma's plugboard, it's not restricted to pairs, so it's entered like a rotor (without stepping). To create your own rotor, enter the letters that the rotor maps A to Z to, in order, optionally followed by <code>&lt;</code> then a list of stepping points.<br><br>More detailed descriptions of the Enigma, Typex and Bombe operations <a href='https://github.com/gchq/CyberChef/wiki/Enigma,-the-Bombe,-and-Typex'>can be found here</a>.";
+        this.infoURL = "https://wikipedia.org/wiki/Typex";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "1st (left-hand) rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "1st rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "1st rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "1st rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "2nd rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 1
+            },
+            {
+                name: "2nd rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "2nd rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "2nd rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "3rd (middle) rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 2
+            },
+            {
+                name: "3rd rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "3rd rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "3rd rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "4th (static) rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 3
+            },
+            {
+                name: "4th rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "4th rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "4th rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "5th (right-hand, static) rotor",
+                type: "editableOption",
+                value: ROTORS,
+                defaultIndex: 4
+            },
+            {
+                name: "5th rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "5th rotor ring setting",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "5th rotor initial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "Reflector",
+                type: "editableOption",
+                value: REFLECTORS
+            },
+            {
+                name: "Plugboard",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Typex keyboard emulation",
+                type: "option",
+                value: ["None", "Encrypt", "Decrypt"]
+            },
+            {
+                name: "Strict output",
+                hint: "Remove non-alphabet letters and group output",
+                type: "boolean",
+                value: true
+            },
+        ];
+    }
+
+    /**
+     * Helper - for ease of use rotors are specified as a single string; this
+     * method breaks the spec string into wiring and steps parts.
+     *
+     * @param {string} rotor - Rotor specification string.
+     * @param {number} i - For error messages, the number of this rotor.
+     * @returns {string[]}
+     */
+    parseRotorStr(rotor, i) {
+        if (rotor === "") {
+            throw new OperationError(`Rotor ${i} must be provided.`);
+        }
+        if (!rotor.includes("<")) {
+            return [rotor, ""];
+        }
+        return rotor.split("<", 2);
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const reflectorstr = args[20];
+        const plugboardstr = args[21];
+        const typexKeyboard = args[22];
+        const removeOther = args[23];
+        const rotors = [];
+        for (let i=0; i<5; i++) {
+            const [rotorwiring, rotorsteps] = this.parseRotorStr(args[i*4]);
+            rotors.push(new Rotor(rotorwiring, rotorsteps, args[i*4 + 1], args[i*4+2], args[i*4+3]));
+        }
+        // Rotors are handled in reverse
+        rotors.reverse();
+        const reflector = new Reflector(reflectorstr);
+        let plugboardstrMod = plugboardstr;
+        if (plugboardstrMod === "") {
+            plugboardstrMod = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        }
+        const plugboard = new Plugboard(plugboardstrMod);
+        if (removeOther) {
+            if (typexKeyboard === "Encrypt") {
+                input = input.replace(/[^A-Za-z0-9 /%£()',.-]/g, "");
+            } else {
+                input = input.replace(/[^A-Za-z]/g, "");
+            }
+        }
+        const typex = new TypexMachine(rotors, reflector, plugboard, typexKeyboard);
+        let result = typex.crypt(input);
+        if (removeOther && typexKeyboard !== "Decrypt") {
+            // Five character cipher groups is traditional
+            result = result.replace(/([A-Z]{5})(?!$)/g, "$1 ");
+        }
+        return result;
+    }
+
+    /**
+     * Highlight Typex
+     * This is only possible if we're passing through non-alphabet characters.
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlight(pos, args) {
+        if (args[18] === false) {
+            return pos;
+        }
+    }
+
+    /**
+     * Highlight Typex in reverse
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlightReverse(pos, args) {
+        if (args[18] === false) {
+            return pos;
+        }
+    }
+
+}
+
+export default Typex;

src/web/App.mjs

@@ -51,10 +51,12 @@ class App {
      */
     setup() {
         document.dispatchEvent(this.manager.appstart);
+
         this.initialiseSplitter();
         this.loadLocalStorage();
         this.populateOperationsList();
         this.manager.setup();
+        this.manager.output.saveBombe();
         this.resetLayout();
         this.setCompileMessage();
 
@@ -122,6 +124,9 @@ class App {
         // Reset attemptHighlight flag
         this.options.attemptHighlight = true;
 
+        // Remove all current indicators
+        this.manager.recipe.updateBreakpointIndicator(false);
+
         this.manager.worker.bake(
             this.getInput(),        // The user's input
             this.getRecipeConfig(), // The configuration of the recipe
@@ -474,6 +479,7 @@ class App {
             const item = this.manager.recipe.addOperation(recipeConfig[i].op);
 
             // Populate arguments
+            log.debug(`Populating arguments for ${recipeConfig[i].op}`);
             const args = item.querySelectorAll(".arg");
             for (let j = 0; j < args.length; j++) {
                 if (recipeConfig[i].args[j] === undefined) continue;
@@ -499,6 +505,8 @@ class App {
                 item.querySelector(".breakpoint").click();
             }
 
+            this.manager.recipe.triggerArgEvents(item);
+
             this.progress = 0;
         }
 

src/web/HTMLIngredient.mjs

@@ -45,7 +45,7 @@ class HTMLIngredient {
      */
     toHtml() {
         let html = "",
-            i, m;
+            i, m, eventFn;
 
         switch (this.type) {
             case "string":
@@ -151,10 +151,11 @@ class HTMLIngredient {
                 </div>`;
                 break;
             case "populateOption":
+            case "populateMultiOption":
                 html += `<div class="form-group">
                     <label for="${this.id}" class="bmd-label-floating">${this.name}</label>
                     <select
-                        class="form-control arg"
+                        class="form-control arg no-state-change populate-option"
                         id="${this.id}"
                         arg-name="${this.name}"
                         ${this.disabled ? "disabled" : ""}>`;
@@ -164,14 +165,20 @@ class HTMLIngredient {
                     } else if ((m = this.value[i].name.match(/\[\/([a-z0-9 -()^]+)\]/i))) {
                         html += "</optgroup>";
                     } else {
-                        html += `<option populate-value="${Utils.escapeHtml(this.value[i].value)}">${this.value[i].name}</option>`;
+                        const val = this.type === "populateMultiOption" ?
+                            JSON.stringify(this.value[i].value) :
+                            this.value[i].value;
+                        html += `<option populate-value='${Utils.escapeHtml(val)}'>${this.value[i].name}</option>`;
                     }
                 }
                 html += `</select>
                     ${this.hint ? "<span class='bmd-help'>" + this.hint + "</span>" : ""}
                 </div>`;
 
-                this.manager.addDynamicListener("#" + this.id, "change", this.populateOptionChange, this);
+                eventFn = this.type === "populateMultiOption" ?
+                    this.populateMultiOptionChange :
+                    this.populateOptionChange;
+                this.manager.addDynamicListener("#" + this.id, "change", eventFn, this);
                 break;
             case "editableOption":
                 html += `<div class="form-group input-group">
@@ -243,6 +250,27 @@ class HTMLIngredient {
                     ${this.hint ? "<span class='bmd-help'>" + this.hint + "</span>" : ""}
                 </div>`;
                 break;
+            case "argSelector":
+                html += `<div class="form-group inline">
+                    <label for="${this.id}" class="bmd-label-floating inline">${this.name}</label>
+                    <select
+                        class="form-control arg inline arg-selector"
+                        id="${this.id}"
+                        arg-name="${this.name}"
+                        ${this.disabled ? "disabled" : ""}>`;
+                for (i = 0; i < this.value.length; i++) {
+                    html += `<option ${this.defaultIndex === i ? "selected" : ""}
+                        turnon="${JSON.stringify(this.value[i].on || [])}"
+                        turnoff="${JSON.stringify(this.value[i].off || [])}">
+                            ${this.value[i].name}
+                        </option>`;
+                }
+                html += `</select>
+                    ${this.hint ? "<span class='bmd-help'>" + this.hint + "</span>" : ""}
+                </div>`;
+
+                this.manager.addDynamicListener(".arg-selector", "change", this.argSelectorChange, this);
+                break;
             default:
                 break;
         }
@@ -258,6 +286,9 @@ class HTMLIngredient {
      * @param {event} e
      */
     populateOptionChange(e) {
+        e.preventDefault();
+        e.stopPropagation();
+
         const el = e.target;
         const op = el.parentNode.parentNode;
         const target = op.querySelectorAll(".arg")[this.target];
@@ -270,6 +301,37 @@ class HTMLIngredient {
     }
 
 
+    /**
+     * Handler for populate multi option changes.
+     * Populates the relevant arguments with the specified values.
+     *
+     * @param {event} e
+     */
+    populateMultiOptionChange(e) {
+        e.preventDefault();
+        e.stopPropagation();
+
+        const el = e.target;
+        const op = el.parentNode.parentNode;
+        const args = op.querySelectorAll(".arg");
+        const targets = this.target.map(i => args[i]);
+        const vals = JSON.parse(el.childNodes[el.selectedIndex].getAttribute("populate-value"));
+        const evt = new Event("change");
+
+        for (let i = 0; i < targets.length; i++) {
+            targets[i].value = vals[i];
+        }
+
+        // Fire change event after all targets have been assigned
+        this.manager.recipe.ingChange();
+
+        // Send change event for each target once all have been assigned, to update the label placement.
+        for (const target of targets) {
+            target.dispatchEvent(evt);
+        }
+    }
+
+
     /**
      * Handler for editable option clicks.
      * Populates the input box with the selected value.
@@ -290,6 +352,33 @@ class HTMLIngredient {
         this.manager.recipe.ingChange();
     }
 
+
+    /**
+     * Handler for argument selector changes.
+     * Shows or hides the relevant arguments for this operation.
+     *
+     * @param {event} e
+     */
+    argSelectorChange(e) {
+        e.preventDefault();
+        e.stopPropagation();
+
+        const option = e.target.options[e.target.selectedIndex];
+        const op = e.target.closest(".operation");
+        const args = op.querySelectorAll(".ingredients .form-group");
+        const turnon = JSON.parse(option.getAttribute("turnon"));
+        const turnoff = JSON.parse(option.getAttribute("turnoff"));
+
+        args.forEach((arg, i) => {
+            if (turnon.includes(i)) {
+                arg.classList.remove("d-none");
+            }
+            if (turnoff.includes(i)) {
+                arg.classList.add("d-none");
+            }
+        });
+    }
+
 }
 
 export default HTMLIngredient;

src/web/OutputWaiter.mjs

@@ -336,24 +336,54 @@ class OutputWaiter {
 
 
     /**
-     * Shows or hides the loading icon.
+     * Save bombe object then remove it from the DOM so that it does not cause performance issues.
+     */
+    saveBombe() {
+        this.bombeEl = document.getElementById("bombe");
+        this.bombeEl.parentNode.removeChild(this.bombeEl);
+    }
+
+
+    /**
+     * Shows or hides the output loading screen.
+     * The animated Bombe SVG, whilst quite aesthetically pleasing, is reasonably CPU
+     * intensive, so we remove it from the DOM when not in use. We only show it if the
+     * recipe is taking longer than 200ms. We add it to the DOM just before that so that
+     * it is ready to fade in without stuttering.
      *
-     * @param {boolean} value
+     * @param {boolean} value - true == show loader
      */
     toggleLoader(value) {
+        clearTimeout(this.appendBombeTimeout);
+        clearTimeout(this.outputLoaderTimeout);
+
         const outputLoader = document.getElementById("output-loader"),
-            outputElement = document.getElementById("output-text");
+            outputElement = document.getElementById("output-text"),
+            animation = document.getElementById("output-loader-animation");
 
         if (value) {
             this.manager.controls.hideStaleIndicator();
-            this.bakingStatusTimeout = setTimeout(function() {
+
+            // Start a timer to add the Bombe to the DOM just before we make it
+            // visible so that there is no stuttering
+            this.appendBombeTimeout = setTimeout(function() {
+                animation.appendChild(this.bombeEl);
+            }.bind(this), 150);
+
+            // Show the loading screen
+            this.outputLoaderTimeout = setTimeout(function() {
                 outputElement.disabled = true;
                 outputLoader.style.visibility = "visible";
                 outputLoader.style.opacity = 1;
                 this.manager.controls.toggleBakeButtonFunction(true);
             }.bind(this), 200);
         } else {
-            clearTimeout(this.bakingStatusTimeout);
+            // Remove the Bombe from the DOM to save resources
+            this.outputLoaderTimeout = setTimeout(function () {
+                try {
+                    animation.removeChild(this.bombeEl);
+                } catch (err) {}
+            }.bind(this), 500);
             outputElement.disabled = false;
             outputLoader.style.opacity = 0;
             outputLoader.style.visibility = "hidden";

src/web/RecipeWaiter.mjs

@@ -205,6 +205,7 @@ class RecipeWaiter {
      * @fires Manager#statechange
      */
     ingChange(e) {
+        if (e && e.target && e.target.classList.contains("no-state-change")) return;
         window.dispatchEvent(this.manager.statechange);
     }
 
@@ -340,10 +341,11 @@ class RecipeWaiter {
     /**
      * Moves or removes the breakpoint indicator in the recipe based on the position.
      *
-     * @param {number} position
+     * @param {number|boolean} position - If boolean, turn off all indicators
      */
     updateBreakpointIndicator(position) {
         const operations = document.querySelectorAll("#rec-list li.operation");
+        if (typeof position === "boolean") position = operations.length;
         for (let i = 0; i < operations.length; i++) {
             if (i === position) {
                 operations[i].classList.add("break");
@@ -429,6 +431,23 @@ class RecipeWaiter {
     }
 
 
+    /**
+     * Triggers various change events for operation arguments that have just been initialised.
+     *
+     * @param {HTMLElement} op
+     */
+    triggerArgEvents(op) {
+        // Trigger populateOption and argSelector events
+        const triggerableOptions = op.querySelectorAll(".populate-option, .arg-selector");
+        const evt = new Event("change", {bubbles: true});
+        if (triggerableOptions.length) {
+            for (const el of triggerableOptions) {
+                el.dispatchEvent(evt);
+            }
+        }
+    }
+
+
     /**
      * Handler for operationadd events.
      *
@@ -438,6 +457,8 @@ class RecipeWaiter {
      */
     opAdd(e) {
         log.debug(`'${e.target.querySelector(".op-title").textContent}' added to recipe`);
+
+        this.triggerArgEvents(e.target);
         window.dispatchEvent(this.manager.statechange);
     }
 

src/web/html/index.html

@@ -81,7 +81,11 @@
                     if (!el.classList.contains("loading"))
                         el.classList.add("loading"); // Causes CSS transition on first message
                     el.innerHTML = msg;
-                } catch (err) {} // Ignore errors if DOM not yet ready
+                } catch (err) {
+                    // This error was likely caused by the DOM not being ready yet,
+                    // so we wait another second and then try again.
+                    setTimeout(changeLoadingMsg, 1000);
+                }
             }
 
             changeLoadingMsg();
@@ -319,7 +323,9 @@
                                 </div>
                             </div>
                             <div id="output-loader">
-                                <div class="loader"></div>
+                                <div id="output-loader-animation">
+                                    <object id="bombe" data="<%- require('../static/images/bombe.svg') %>" width="100%" height="100%"></object>
+                                </div>
                                 <div class="loading-msg"></div>
                             </div>
                         </div>

src/web/static/images/bombe.svg

@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Turing-Welchman Bombe SVG animation
+
+    @author n1474335 [n1474335@gmail.com]
+    @copyright Crown Copyright 2019
+    @license Apache-2.0
+-->
+<svg version="1.2" baseProfile="tiny" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"
+    x="0px" y="0px" width="550px" height="350px" viewBox="0 0 550 350" xml:space="preserve" onload="setup(evt)">
+<script type="text/ecmascript">
+    // <![CDATA[
+    function setup(evt) {
+        const allRotors = evt.target.ownerDocument.querySelectorAll('.rotor');
+        const rotors = [];
+        const initTime = Date.now();
+        const tick = 360/26;
+        const speed = 1000; // Time for one full rotation of the fast rotor
+ 
+        for (const rotor of allRotors) {
+            const row = parseInt(rotor.classList.value.match(/row(\d)/)[1], 10);
+            const startPos = row === 2 ? tick * Math.floor(Math.random()*26) : 0;
+            const bbox = rotor.getBBox();
+            const x = bbox.width/2 + bbox.x;
+            const y = bbox.height/2 + bbox.y;
+            const wait = row === 0 ? speed/26/1.5 : row === 1 ? speed : speed*26;
+ 
+            rotor.setAttribute("transform", "rotate(" + startPos + ", " + x + ", " + y + ")");
+ 
+            rotors.push({
+                el: rotor,
+                pos: startPos,
+                x: x,
+                y: y,
+                last: initTime,
+                wait: wait
+            });
+        }
+ 
+        setInterval(function() {
+            const now = Date.now();
+            for (const rotor of rotors) {
+                if (now > (rotor.last + rotor.wait)) {
+                    const numTicks = Math.floor((now - rotor.last) / rotor.wait);
+                    rotor.pos = (rotor.pos + tick * numTicks) % 360;
+                    rotor.last = rotor.last + rotor.wait * numTicks;
+                    rotor.el.setAttribute("transform", "rotate(" + rotor.pos + ", " + rotor.x + ", " + rotor.y + ")");
+                } else {
+                    // Don't bother looking at the rest
+                    break;
+                }
+            }
+        }, speed/26/1.5 - 5);
+    }
+    // ]]>
+</script>
+<style>
+    .row0 {--primary-color: #e5d41b;}
+    .row1 {--primary-color: #be1e2d;}
+    .row2 {--primary-color: #337f24;}
+</style>
+ 
+<symbol id="rotor">
+    <g transform="scale(0.1)">
+        <circle id="casing" class="ring-color" style="fill: var(--primary-color, #be1e2d)" cx="692" cy="674" r="505"/>
+        <circle id="alphabet-ring" fill="#7a5340" cx="692" cy="674" r="477"/>
+        <circle id="face" fill="#412612" cx="692" cy="674" r="412"/>
+        <circle id="plate" fill="#F1F2F2" cx="692" cy="674" r="185"/>
+        <g id="alphabet" fill="#ffffff" font-family="sans-serif" font-size="36">
+            <text transform="matrix(0.9731 0.2303 -0.2303 0.9731 779.8848 256.5488)">Z</text>
+            <text transform="matrix(0.8903 0.4554 -0.4554 0.8903 875.2021 288.6948)">Y</text>
+            <text transform="matrix(0.7561 0.6545 -0.6545 0.7561 961.8311 343.6372)">X</text>
+            <text transform="matrix(0.5696 0.8219 -0.8219 0.5696 1033.0146 417.4619)">W</text>
+            <text transform="matrix(0.3454 0.9385 -0.9385 0.3454 1088.1104 515.4634)">V</text>
+            <text transform="matrix(0.1078 0.9942 -0.9942 0.1078 1114.4678 614.5894)">U</text>
+            <text transform="matrix(-0.1302 0.9915 -0.9915 -0.1302 1116.1533 719.1523)">T</text>
+            <text transform="matrix(-0.3623 0.9321 -0.9321 -0.3623 1093.8984 817.2373)">S</text>
+            <text transform="matrix(-0.5767 0.817 -0.817 -0.5767 1048.0635 908.9912)">R</text>
+            <text transform="matrix(-0.7588 0.6514 -0.6514 -0.7588 980.2002 988.5342)">Q</text>
+            <text transform="matrix(-0.8942 0.4476 -0.4476 -0.8942 893.3154 1050.1416)">P</text>
+            <text transform="matrix(-0.9766 0.215 -0.215 -0.9766 797.7471 1087.3965)">O</text>
+            <text transform="matrix(-0.9996 -0.0298 0.0298 -0.9996 692.0405 1100.5684)">N</text>
+            <text transform="matrix(-0.961 -0.2765 0.2765 -0.961 588.2832 1087.9443)">M</text>
+            <text transform="matrix(-0.8654 -0.5011 0.5011 -0.8654 487.3003 1048.2471)">L</text>
+            <text transform="matrix(-0.7244 -0.6894 0.6894 -0.7244 406.814 991.1895)">K</text>
+            <text transform="matrix(-0.5456 -0.838 0.838 -0.5456 339.3418 913.8809)">J</text>
+            <text transform="matrix(-0.3508 -0.9364 0.9364 -0.3508 294.3491 828.2446)">I</text>
+            <text transform="matrix(-0.1295 -0.9916 0.9916 -0.1295 270.9233 742.6519)">H</text>
+            <text transform="matrix(0.1153 -0.9933 0.9933 0.1153 266.8784 638.1958)">G</text>
+            <text transform="matrix(0.3526 -0.9358 0.9358 0.3526 288.9976 533.9849)">F</text>
+            <text transform="matrix(0.5645 -0.8255 0.8255 0.5645 333.0195 443.5317)">E</text>
+            <text transform="matrix(0.7459 -0.666 0.666 0.7459 398.4409 364.5073)">D</text>
+            <text transform="matrix(0.8853 -0.4651 0.4651 0.8853 482.4824 302.3418)">C</text>
+            <text transform="matrix(0.9716 -0.2365 0.2365 0.9716 579.1396 262.5479)">B</text>
+            <text transform="matrix(0.9999 0.0162 -0.0162 0.9999 680.5581 247.4321)">A</text>
+        </g>
+        <g id="holes">
+            <circle stroke="#C49A6C" cx="692" cy="438.782" r="40.816"/>
+            <circle stroke="#C49A6C" cx="927.219" cy="674" r="40.816"/>
+            <circle stroke="#C49A6C" cx="692" cy="909.219" r="40.816"/>
+            <circle stroke="#C49A6C" cx="456.781" cy="674" r="40.816"/>
+            <circle stroke="#C49A6C" cx="574.391" cy="470.295" r="40.816"/>
+            <circle stroke="#C49A6C" cx="895.706" cy="556.39" r="40.816"/>
+            <circle stroke="#C49A6C" cx="809.609" cy="877.706" r="40.816"/>
+            <circle stroke="#C49A6C" cx="488.295" cy="791.609" r="40.816"/>
+            <circle stroke="#C49A6C" cx="488.295" cy="556.39" r="40.816"/>
+            <circle stroke="#C49A6C" cx="809.609" cy="470.293" r="40.816"/>
+            <circle stroke="#C49A6C" cx="895.706" cy="791.609" r="40.816"/>
+            <circle stroke="#C49A6C" cx="574.391" cy="877.705" r="40.816"/>
+        </g>
+        <g id="plate-screws">
+            <g>
+                <circle fill="#BCBEC0" stroke="#808285" stroke-width="2" cx="693.223" cy="543.521" r="25.342"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="693.446" y1="519.729" x2="693" y2="567.311"/>
+            </g>
+            <g>
+                <circle fill="#BCBEC0" stroke="#808285" stroke-width="2" cx="822.479" cy="675.221" r="25.342"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="798.689" y1="674.999" x2="846.271" y2="675.445"/>
+            </g>
+            <g>
+                <circle fill="#BCBEC0" stroke="#808285" stroke-width="2" cx="562.605" cy="673.886" r="25.341"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="538.814" y1="673.663" x2="586.396" y2="674.108"/>
+            </g>
+            <g>
+                <circle fill="#BCBEC0" stroke="#808285" stroke-width="2" cx="691.863" cy="805.587" r="25.341"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="692.086" y1="781.798" x2="691.64" y2="829.379"/>
+            </g>
+        </g>
+        <path id="pin" fill-rule="evenodd" fill="#D1D3D4" stroke="#939598"
+            d="M956.275,448.71c-0.969,0.389-1.924,0.836-2.848,1.302
+            c-5.875,2.962-10.965,7.197-16.168,11.152c-5.885,4.475-11.93,8.739-17.834,13.187c-10.688,8.049-21.533,15.888-32.24,23.907
+            c-2.199,1.643-4.436,3.238-6.609,4.912c-14.525,11.139-28.867,22.534-43.559,33.452c-9.428,7.004-19.436,13.346-28.354,21.005
+            c-12.459,10.694-24.723,22.592-35.869,34.65c-5.281,5.711-10.656,11.297-16.243,16.711c-3.063,2.967-5.874,5.382-8.114,8.997
+            c-2.256,3.646-4.589,7.558-6.059,11.586c-2.757,7.565,0.999,14.189,3.413,21.241c5.533,16.161-0.56,32.288-11.42,44.675
+            c-6.989,7.974-15.39,15.932-25.247,20.16c-5.45,2.337-12.057,3.965-18.012,4.105c-6.159,0.148-11.914-1.53-17.568-3.802
+            c-5.215-2.094-14.936-7.879-20.029-3.758c-4.529,3.667-8.937,7.59-13.502,11.251c-1.359,1.088-2.961,2.043-4.15,3.33
+            c0.001,0,16.224-17.545,16.596-17.948c2.86-3.092,0.168-9.246-1.066-12.486c-2.088-5.471-3.199-10.951-4.633-16.611
+            c-1.02-4.023-1.841-8.044-1.548-12.215c0.637-9.093,3.98-19.698,8.918-27.356c6.4-9.925,16.834-18.061,27.527-22.879
+            c14.831-6.684,29.543-3.252,44.133,2.23c5.441,2.044,12.285-2.206,16.829-4.831c6.116-3.534,11.542-8.171,16.117-13.547
+            c9.109-10.707,19.505-20.119,29.089-30.368c4.945-5.288,10.229-10.295,15.316-15.45l25.586-29.884l31.963-43.979
+            c0,0,29.025-38.288,29.113-38.409c9.037-11.917,24.822-22.94,25.588-39.161c0.617-13.024-14.27-17.184-24.727-16.841
+            c-7.41,0.242-16.311,0.894-23.117,4.161c-15.1,7.248-28.342,15.616-34.676,31.979c-2.504,6.464-4.865,12.671-6.76,19.319
+            c-2.051,7.208-5.539,11.212-9.826,17.088c-10.779,14.778-24.389,24.73-40.998,32.1c-4.74,2.104-9.229,4.293-14.08,6.129
+            c-3.961,1.5-9.706,3.104-12.91,5.747c-5.948,4.907-10.334,14.214-13.357,21.205c-1.911,4.418-3.278,9.046-5.009,13.535
+            c-2.069,5.37-2.532,11.326-4.88,16.507c-1.33,2.935-1.91,5.994-4.104,8.414c-2.609,2.877-4.623,4.939-8.159,6.693
+            c-3.45,1.713-6.487,3.997-10.305,4.736c-2.717,0.528-5.277,1.418-8.023,1.794c-8.203,1.127-16.54,1.73-24.695,3.159
+            c-3.994,0.7-7.947,2.283-11.792,3.534c-5.167,1.681-10.116,5.972-14.846,8.78c-10.3,6.119-20.007,15.004-27.479,24.277
+            c-5.337,6.625-8.976,14.32-11.926,22.251c-2.169,5.833-4.357,11.754-5.061,17.977c-0.564,5.001-0.074,10.062-0.502,15.077
+            c-0.706,8.26-3.203,17.47-9.294,23.414c-5.363,5.234-14.174,10.834-21.666,12.043c-7.607,1.226-15.016,0.118-20.697-5.407
+            c-5.092-4.954-9.277-11.304-15.816-14.539c-3.873-1.917-8.116-2.357-12.351-1.588c-10.82,1.965-17.767,7.374-18.428,18.637
+            c-0.545,9.325,1.999,15.171,6.731,22.947c4.323,7.103,5.315,15.456,9.255,22.756c4.052,7.503,7.825,15.248,12.169,22.583
+            c3.05,5.156,6.832,9.664,10.749,14.176c1.717,1.978,3.554,4.901,5.732,6.378c5.639,3.827,10.784,3.305,17.032,1.951
+            c2.175-0.473,3.233,0.047,4.694,1.679c1.557,1.74,1.399,1.609,0.505,3.68c-2.732,6.329-4.573,12.085-0.1,18.199
+            c3.421,4.675,8.728,9.01,13.531,12.271c7.165,4.865,14.799,8.835,22.414,12.933c8.94,4.808,18.489,8.188,27.963,11.765
+            c6.597,2.491,11.068,7.997,17.229,11.186c6.945,3.595,13.775,1.032,19.691-3.353c5.688-4.216,9.634-9.578,10.066-16.804
+            c0.415-6.938-1.239-14.501-5.51-20.082c-4.163-5.439-10.751-8.996-13.229-15.664c-2.506-6.741-0.296-14.597,1.313-21.3
+            c1.606-6.687,3.798-12.642,9.227-17.17c5.458-4.554,12.49-7.653,19.583-8.294c7.954-0.721,15.985-0.105,23.912-1.162
+            c7.9-1.052,15.855-4.074,22.918-7.696c5.104-2.616,9.105-6.979,13.309-10.789c8.875-8.052,18.1-16.759,23.735-27.459
+            c4.125-7.834,8.521-15.675,11.016-24.222c1.154-3.962,2.098-8.083,2.316-12.204c0.424-7.886-1.686-16.176,2.564-23.391
+            c5.645-9.582,14.869-17.408,25.563-20.561c8.727-2.571,17.697-4.624,25.963-8.522c7.234-3.413,16-7.686,20.182-14.833
+            c1.822-3.116,3.109-6.775,4.361-10.158c1.752-4.719,3.648-9.389,5.4-14.108c2.082-5.625,4.016-10.898,6.887-16.146
+            c2.551-4.656,6.072-7.849,9.471-11.864c2.504-2.956,4.539-5.815,7.773-8.031c3.229-2.208,6.805-3.835,10.088-5.952
+            c3.469-2.237,6.955-4.47,10.578-6.445c4.242-2.312,8.557-3.716,13.207-4.92c10.176-2.643,19.592-6.376,26.959-14.134
+            c6.977-7.349,13.82-15.747,16.816-25.566c2.938-9.634,3.967-20.147,2.086-30.07c-0.973-5.124-2.291-11.331-5.824-15.367
+            C964.873,446.457,960.432,447.042,956.275,448.71z"/>
+        <circle id="center-nut" fill="#d1a26a" stroke="#a88e75" stroke-width="25" cx="692" cy="674" r="60"/>
+        <g id="pin-screws">
+            <circle fill="#BCBEC0" stroke="#58595B" cx="768.174" cy="545.468" r="18.485"/>
+            <line fill="#BCBEC0" stroke="#939598" stroke-width="5" x1="750.079" y1="545.298" x2="786.273" y2="545.635"/>
+            <path fill="#BCBEC0" stroke="#58595B" d="M819.834,579.439c-10.211-0.094-18.564,8.103-18.66,18.313
+                c-0.094,10.208,8.102,18.562,18.313,18.657c10.205,0.095,18.563-8.102,18.656-18.312
+                C838.24,587.889,830.041,579.535,819.834,579.439z"/>
+            <line fill="#BCBEC0" stroke="#939598" stroke-width="5" x1="819.49" y1="616.02" x2="819.826" y2="579.826"/>
+            <circle fill="#BCBEC0" stroke="#58595B" cx="626.351" cy="736.463" r="18.486"/>
+            <line fill="#BCBEC0" stroke="#939598" stroke-width="5" x1="639.026" y1="749.378" x2="613.672" y2="723.543"/>
+            <circle fill="#BCBEC0" stroke="#58595B" cx="526.668" cy="709.157" r="18.485"/>
+            <line fill="#BCBEC0" stroke="#939598" stroke-width="5" x1="526.498" y1="727.252" x2="526.837" y2="691.059"/>
+            <circle fill="#BCBEC0" stroke="#58595B" cx="654.839" cy="839.752" r="18.486"/>
+            <line fill="#BCBEC0" stroke="#939598" stroke-width="5" x1="636.744" y1="839.583" x2="672.937" y2="839.922"/>
+        </g>
+        <g id="plate-mini-screws">
+            <circle fill="#E6E7E8" stroke="#A7A9AC" cx="786.206" cy="769.987" r="15.332"/>
+            <line fill="#E6E7E8" stroke="#A7A9AC" stroke-width="5" x1="775.494" y1="780.5" x2="796.92" y2="759.472"/>
+            <circle fill="#E6E7E8" stroke="#A7A9AC" cx="599.966" cy="580.227" r="15.333"/>
+            <line fill="#E6E7E8" stroke="#A7A9AC" stroke-width="5" x1="589.254" y1="590.74" x2="610.682" y2="569.712"/>
+        </g>
+        <g id="spring">
+            <line fill="none" stroke="#808285" stroke-width="2" x1="561.307" y1="722.169" x2="534.592" y2="739.515"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="565.744" y1="726.689" x2="539.028" y2="744.034"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="570.179" y1="731.21" x2="543.465" y2="748.555"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="574.616" y1="735.73" x2="547.901" y2="753.074"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="579.052" y1="740.25" x2="552.336" y2="757.596"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="583.722" y1="745.008" x2="557.007" y2="762.354"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="588.158" y1="749.529" x2="561.443" y2="766.873"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="592.595" y1="754.047" x2="565.879" y2="771.393"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="597.03" y1="758.568" x2="570.315" y2="775.913"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="601.466" y1="763.088" x2="574.751" y2="780.434"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="605.902" y1="767.608" x2="579.188" y2="784.953"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="610.338" y1="772.128" x2="583.623" y2="789.474"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="614.775" y1="776.647" x2="588.06" y2="793.994"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="619.211" y1="781.169" x2="592.496" y2="798.513"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="623.648" y1="785.688" x2="596.933" y2="803.034"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="628.084" y1="790.209" x2="601.369" y2="807.553"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="632.52" y1="794.728" x2="605.806" y2="812.074"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="636.956" y1="799.249" x2="610.241" y2="816.593"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="641.393" y1="803.77" x2="614.678" y2="821.113"/>
+            <line fill="none" stroke="#808285" stroke-width="2" x1="645.83" y1="808.288" x2="619.114" y2="825.634"/>
+        </g>
+        <g id="face-nuts">
+            <g>
+                <polygon fill-rule="evenodd" fill="#E6E7E8" stroke="#939598" points="340.617,715.657 300.423,704.888
+                    289.653,664.693 319.077,635.27 359.271,646.04 370.041,686.233   "/>
+                <path fill="#BCBEC0" stroke="#58595B" stroke-width="3" d="M306.759,698.144
+                    c-12.516-12.755-12.326-33.236,0.428-45.752c12.752-12.516,33.234-12.324,45.75,0.431c12.516,12.75,12.324,33.233-0.428,45.748
+                    C339.755,711.087,319.275,710.895,306.759,698.144z"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="351.527" y1="654.208" x2="308.171" y2="696.757"/>
+            </g>
+            <g>
+                <polygon fill-rule="evenodd" fill="#E6E7E8" stroke="#939598" points="702.77,354.86 662.576,344.091
+                    651.806,303.896 681.23,274.473 721.424,285.243 732.194,325.437  "/>
+                <path fill="#603913" stroke="#3C2415" stroke-width="3" d="M668.912,337.347c-12.516-12.755-12.325-33.236,0.428-45.752c12.752-12.516,33.235-12.324,45.75,0.431
+                    c12.516,12.75,12.324,33.233-0.428,45.748C701.909,350.29,681.428,350.098,668.912,337.347z"/>
+                <line fill="#939598" stroke="#3C2415" stroke-width="7" x1="713.68" y1="293.411" x2="670.324" y2="335.96"/>
+                <line fill="#939598" stroke="#3C2415" stroke-width="7" x1="670.324" y1="293.392" x2="713.68" y2="335.941"/>
+            </g>
+            <g>
+                <polygon fill-rule="evenodd" fill="#E6E7E8" stroke="#939598" points="702.77,1072.723 662.576,1061.953
+                    651.806,1021.759 681.23,992.335 721.424,1003.105 732.193,1043.299   "/>
+                <path fill="#603913" stroke="#3C2415" stroke-width="3" d="M668.912,1055.21c-12.516-12.756-12.325-33.236,0.428-45.752c12.752-12.516,33.235-12.324,45.75,0.431
+                    c12.516,12.75,12.324,33.233-0.428,45.747C701.909,1068.152,681.428,1067.96,668.912,1055.21z"/>
+                <line fill="#939598" stroke="#3C2415" stroke-width="7" x1="713.68" y1="1011.272" x2="670.324" y2="1053.822"/>
+                <line fill="#939598" stroke="#3C2415" stroke-width="7" x1="670.324" y1="1011.254" x2="713.68" y2="1053.804"/>
+            </g>
+            <g>
+                <polygon fill-rule="evenodd" fill="#E6E7E8" stroke="#939598" points="1038.556,715.658 1078.749,704.888
+                    1089.521,664.694 1060.097,635.27 1019.901,646.041 1009.132,686.234  "/>
+                <path fill="#BCBEC0" stroke="#58595B" stroke-width="3" d="M1072.413,698.145
+                    c12.516-12.755,12.326-33.236-0.428-45.752c-12.752-12.516-33.234-12.324-45.75,0.431c-12.516,12.75-12.324,33.233,0.428,45.748
+                    C1039.417,711.087,1059.897,710.896,1072.413,698.145z"/>
+                <line fill="#939598" stroke="#808285" stroke-width="7" x1="1027.646" y1="654.208" x2="1071.001" y2="696.757"/>
+            </g>
+        </g>
+    </g>
+</symbol>
+ 
+<g class="rotor row0"><use xlink:href="#rotor" x="0" y="0" /></g>
+<g class="rotor row0"><use xlink:href="#rotor" x="105" y="0" /></g>
+<g class="rotor row0"><use xlink:href="#rotor" x="210" y="0" /></g>
+<g class="rotor row0"><use xlink:href="#rotor" x="315" y="0" /></g>
+<g class="rotor row0"><use xlink:href="#rotor" x="420" y="0" /></g>
+<g class="rotor row1"><use xlink:href="#rotor" x="0" y="105" /></g>
+<g class="rotor row1"><use xlink:href="#rotor" x="105" y="105" /></g>
+<g class="rotor row1"><use xlink:href="#rotor" x="210" y="105" /></g>
+<g class="rotor row1"><use xlink:href="#rotor" x="315" y="105" /></g>
+<g class="rotor row1"><use xlink:href="#rotor" x="420" y="105" /></g>
+<g class="rotor row2"><use xlink:href="#rotor" x="0" y="210" /></g>
+<g class="rotor row2"><use xlink:href="#rotor" x="105" y="210" /></g>
+<g class="rotor row2"><use xlink:href="#rotor" x="210" y="210" /></g>
+<g class="rotor row2"><use xlink:href="#rotor" x="315" y="210" /></g>
+<g class="rotor row2"><use xlink:href="#rotor" x="420" y="210" /></g>
+</svg>

src/web/stylesheets/layout/_io.css

@@ -73,6 +73,30 @@
     background-color: var(--primary-background-colour);
     visibility: hidden;
     opacity: 0;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+
+    transition: all 0.5s ease;
+}
+
+#output-loader-animation {
+    display: block;
+    position: absolute;
+    width: 60%;
+    height: 60%;
+    top: 10%;
+    transition: all 0.5s ease;
+}
+
+#output-loader .loading-msg {
+    opacity: 1;
+    font-family: var(--primary-font-family);
+    line-height: var(--primary-line-height);
+    color: var(--primary-font-colour);
+    left: unset;
+    top: 30%;
+    position: relative;
 
     transition: all 0.5s ease;
 }
@@ -139,16 +163,6 @@
     margin-bottom: 5px;
 }
 
-#output-loader .loading-msg {
-    opacity: 1;
-    font-family: var(--primary-font-family);
-    line-height: var(--primary-line-height);
-    color: var(--primary-font-colour);
-    top: 50%;
-
-    transition: all 0.5s ease;
-}
-
 #magic {
     opacity: 1;
     visibility: visibile;

src/web/stylesheets/preloader.css

@@ -65,8 +65,8 @@
     left: calc(50% - 200px);
     top: calc(50% + 50px);
     text-align: center;
-    margin-top: 50px;
     opacity: 0;
+    font-size: 18px;
 }
 
 .loading-msg.loading {

tests/operations/index.mjs

@@ -83,6 +83,10 @@ import "./tests/Media";
 import "./tests/ToFromInsensitiveRegex";
 import "./tests/YARA.mjs";
 import "./tests/ConvertCoordinateFormat";
+import "./tests/Enigma";
+import "./tests/Bombe";
+import "./tests/MultipleBombe";
+import "./tests/Typex";
 
 // Cannot test operations that use the File type yet
 //import "./tests/SplitColourChannels";

tests/operations/tests/Bombe.mjs

@@ -0,0 +1,242 @@
+/**
+ * Bombe machine tests.
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import TestRegister from "../TestRegister";
+
+TestRegister.addTests([
+    {
+        // Plugboard for this test is BO LC KE GA
+        name: "Bombe: 3 rotor (self-stecker)",
+        input: "BBYFLTHHYIJQAYBBYS",
+        expectedMatch: /<td>LGA<\/td> {2}<td>SS<\/td> {2}<td>VFISUSGTKSTMPSUNAK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTMESSAGE", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        // This test produces a menu that doesn't use the first letter, which is also a good test
+        name: "Bombe: 3 rotor (other stecker)",
+        input: "JBYALIHDYNUAAVKBYM",
+        expectedMatch: /<td>LGA<\/td> {2}<td>AG<\/td> {2}<td>QFIMUMAFKMQSKMYNGW<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTMESSAGE", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: crib offset",
+        input: "AAABBYFLTHHYIJQAYBBYS", // first three chars here are faked
+        expectedMatch: /<td>LGA<\/td> {2}<td>SS<\/td> {2}<td>VFISUSGTKSTMPSUNAK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTMESSAGE", 3, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: multiple stops",
+        input: "BBYFLTHHYIJQAYBBYS",
+        expectedMatch: /<td>LGA<\/td> {2}<td>TT<\/td> {2}<td>VFISUSGTKSTMPSUNAK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTM", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: checking machine",
+        input: "BBYFLTHHYIJQAYBBYS",
+        expectedMatch: /<td>LGA<\/td> {2}<td>TT AG BO CL EK FF HH II JJ SS YY<\/td> {2}<td>THISISATESTMESSAGE<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTM", 0, true
+                ]
+            }
+        ]
+    },
+    // This test is a bit slow - it takes about 12s on my test hardware
+    {
+        name: "Bombe: 4 rotor",
+        input: "LUOXGJSHGEDSRDOQQX",
+        expectedMatch: /<td>LHSC<\/td> {2}<td>SS<\/td> {2}<td>HHHSSSGQUUQPKSEKWK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "4-rotor",
+                    "LEYJVCNIXWPBQMDRTAKZGFUHOS", // Beta
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV", // B thin
+                    "THISISATESTMESSAGE", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: no crib",
+        input: "JBYALIHDYNUAAVKBYM",
+        expectedMatch: /Crib cannot be empty/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: short crib",
+        input: "JBYALIHDYNUAAVKBYM",
+        expectedMatch: /Crib is too short/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "A", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: invalid crib",
+        input: "JBYALIHDYNUAAVKBYM",
+        expectedMatch: /Invalid crib: .* in both ciphertext and crib/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "AAAAAAAA", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: long crib",
+        input: "JBYALIHDYNUAAVKBYM",
+        expectedMatch: /Crib overruns supplied ciphertext/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "CCCCCCCCCCCCCCCCCCCCCC", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: really long crib",
+        input: "BBBBBBBBBBBBBBBBBBBBBBBBBB",
+        expectedMatch: /Crib is too long/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "AAAAAAAAAAAAAAAAAAAAAAAAAA", 0, false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Bombe: negative offset",
+        input: "AAAAA",
+        expectedMatch: /Offset cannot be negative/,
+        recipeConfig: [
+            {
+                "op": "Bombe",
+                "args": [
+                    "3-rotor",
+                    "",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "BBBBB", -1, false
+                ]
+            }
+        ]
+    },
+    // Enigma tests cover validation of rotors and reflector
+]);

tests/operations/tests/Enigma.mjs

@@ -0,0 +1,565 @@
+/**
+ * Enigma machine tests.
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import TestRegister from "../TestRegister";
+
+TestRegister.addTests([
+    {
+        // Simplest test: A single keypress in the default position on a basic
+        // Enigma.
+        name: "Enigma: basic wiring",
+        input: "G",
+        expectedOutput: "P",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    // Note: start on Z because it steps when the key is pressed
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "Z", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Rotor position test: single keypress, basic rotors, random start
+        // positions, no advancement of other rotors.
+        name: "Enigma: rotor position",
+        input: "A",
+        expectedOutput: "T",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "N",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "F",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "W",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Rotor ring setting test: single keypress, basic rotors, one rotor
+        // ring offset by one, basic start position, no advancement of other
+        // rotors.
+        name: "Enigma: rotor ring setting",
+        input: "A",
+        expectedOutput: "O",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "B", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Rotor ring setting test: single keypress, basic rotors, random ring
+        // settings, basic start position, no advancement of other rotors.
+        name: "Enigma: rotor ring setting 2",
+        input: "A",
+        expectedOutput: "F",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "N", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "F", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "W", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: basic configuration, enough input to cause middle rotor to
+        // step
+        name: "Enigma: stepping",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "UBDZG OWCXL TKSBT MCDLP BMUQO F",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Ensure that we can decrypt an encrypted message.
+        name: "Enigma: reflectivity",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            },
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: with rotors set so we're about to trigger the double step
+        // anomaly
+        name: "Enigma: double step anomaly",
+        input: "AAAAA",
+        expectedOutput: "EQIBM",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "D",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "U",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: with rotors set so we're about to trigger the double step
+        // anomaly
+        name: "Enigma: double step anomaly 2",
+        input: "AAAA",
+        expectedOutput: "BRNC",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "E",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "U",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: with rotors set so we're about to trigger the double step
+        // anomaly
+        name: "Enigma: double step anomaly 3",
+        input: "AAAAA AAA",
+        expectedOutput: "ZEEQI BMG",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "D",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "S",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: with a ring setting
+        name: "Enigma: ring setting stepping",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "PBMFE BOUBD ZGOWC XLTKS BTXSH I",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "H", "Z",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Stepping: with a ring setting and double step
+        name: "Enigma: ring setting double step",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "TEVFK UTIIW EDWVI JPMVP GDEZS P",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "Q", "A",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "C", "D",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "H", "F",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW",
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Four-rotor Enigma, random settings, no plugboard
+        name: "Enigma: four rotor",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "GZXGX QUSUW JPWVI GVBTU DQZNZ J",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "4-rotor",
+                    "LEYJVCNIXWPBQMDRTAKZGFUHOS", "A", "X", // Beta
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "O", "E",
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "P", "F",
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "D", "Q",
+                    "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV", // B thin
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Four-rotor Enigma, different wheel set, no plugboard
+        name: "Enigma: four rotor 2",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "HZJLP IKWBZ XNCWF FIHWL EROOZ C",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "4-rotor",
+                    "FSOKANUERHMBTIYCWLQPZXVGJD", "A", "L", // Gamma
+                    "JPGVOUMFYQBENHZRDKASXLICTW<AN", "A", "J", // VI
+                    "VZBRGITYUPSDNHLXAWMJQOFECK<A", "M", "G", // V
+                    "ESOVPZJAYQUIRHXLNFTGKDCMWB<K", "W", "U", // IV
+                    "AR BD CO EJ FN GT HK IV LM PW QZ SX UY", // C thin
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        // Four-rotor Enigma, different wheel set, random plugboard
+        name: "Enigma: plugboard",
+        input: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        expectedOutput: "GHLIM OJIUW DKLWM JGNJK DYJVD K",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "4-rotor",
+                    "FSOKANUERHMBTIYCWLQPZXVGJD", "A", "I", // Gamma
+                    "NZJHGRCXMYSWBOUFAIVLPEKQDT<AN", "I", "V", // VII
+                    "ESOVPZJAYQUIRHXLNFTGKDCMWB<K", "O", "O", // IV
+                    "FKQHTLXOCBJSPDZRAMEWNIUYGV<AN", "U", "Z", // VIII
+                    "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV", // B thin
+                    "WN MJ LX YB FP QD US IH CE GR"
+                ]
+            }
+        ]
+    },
+    {
+        // Decryption test on above input
+        name: "Enigma: decryption",
+        input: "GHLIM OJIUW DKLWM JGNJK DYJVD K",
+        expectedOutput: "AAAAA AAAAA AAAAA AAAAA AAAAA A",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "4-rotor",
+                    "FSOKANUERHMBTIYCWLQPZXVGJD", "A", "I", // Gamma
+                    "NZJHGRCXMYSWBOUFAIVLPEKQDT<AN", "I", "V", // VII
+                    "ESOVPZJAYQUIRHXLNFTGKDCMWB<K", "O", "O", // IV
+                    "FKQHTLXOCBJSPDZRAMEWNIUYGV<AN", "U", "Z", // VIII
+                    "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV", // B thin
+                    "WN MJ LX YB FP QD US IH CE GR"
+                ]
+            }
+        ]
+    },
+    {
+        // Decryption test on real message
+        name: "Enigma: decryption 2",
+        input: "LANOTCTOUARBBFPMHPHGCZXTDYGAHGUFXGEWKBLKGJWLQXXTGPJJAVTOCKZFSLPPQIHZFXOEBWIIEKFZLCLOAQJULJOYHSSMBBGWHZANVOIIPYRBRTDJQDJJOQKCXWDNBBTYVXLYTAPGVEATXSONPNYNQFUDBBHHVWEPYEYDOHNLXKZDNWRHDUWUJUMWWVIIWZXIVIUQDRHYMNCYEFUAPNHOTKHKGDNPSAKNUAGHJZSMJBMHVTREQEDGXHLZWIFUSKDQVELNMIMITHBHDBWVHDFYHJOQIHORTDJDBWXEMEAYXGYQXOHFDMYUXXNOJAZRSGHPLWMLRECWWUTLRTTVLBHYOORGLGOWUXNXHMHYFAACQEKTHSJW",
+        expectedOutput: "KRKRALLEXXFOLGENDESISTSOFORTBEKANNTZUGEBENXXICHHABEFOLGELNBEBEFEHLERHALTENXXJANSTERLEDESBISHERIGXNREICHSMARSCHALLSJGOERINGJSETZTDERFUEHRERSIEYHVRRGRZSSADMIRALYALSSEINENNACHFOLGEREINXSCHRIFTLSCHEVOLLMACHTUNTERWEGSXABSOFORTSOLLENSIESAEMTLICHEMASSNAHMENVERFUEGENYDIESICHAUSDERGEGENWAERTIGENLAGEERGEBENXGEZXREICHSLEITEIKKTULPEKKJBORMANNJXXOBXDXMMMDURNHFKSTXKOMXADMXUUUBOOIEXKP",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "4-rotor",
+                    "LEYJVCNIXWPBQMDRTAKZGFUHOS", "E", "C", // Beta
+                    "VZBRGITYUPSDNHLXAWMJQOFECK<A", "P", "D", // V
+                    "JPGVOUMFYQBENHZRDKASXLICTW<AN", "E", "S", // VI
+                    "FKQHTLXOCBJSPDZRAMEWNIUYGV<AN", "L", "Z", // VIII
+                    "AR BD CO EJ FN GT HK IV LM PW QZ SX UY", // C thin
+                    "AE BF CM DQ HU JN LX PR SZ VW"
+                ]
+            }
+        ]
+    },
+    {
+        // Non-alphabet characters drop test
+        name: "Enigma: non-alphabet drop",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "ILBDA AMTAZ MORNZ DDIOT U",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "", true
+                ]
+            }
+        ]
+    },
+    {
+        // Non-alphabet characters passthrough test
+        name: "Enigma: non-alphabet passthrough",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "ILBDA, AMTAZ. MORN ZD D IOTU.",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "", false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: rotor validation 1",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Rotor wiring must be 26 unique uppercase letters",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQ", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: rotor validation 2",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Rotor wiring must be 26 unique uppercase letters",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQo", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: rotor validation 3",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Rotor wiring must have each letter exactly once",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQA", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: rotor validation 4",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Rotor steps must be unique",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<RR", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: rotor validation 5",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Rotor steps must be 0-26 unique uppercase letters",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<a", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    // The ring setting and positions are dropdowns in the interface so not
+    // gonna bother testing them
+    {
+        name: "Enigma: reflector validation 1",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Reflector must have exactly 13 pairs covering every letter",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AY BR CU DH EQ FS GL IP JX KN MO", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: reflector validation 2",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Reflector must have exactly 13 pairs covering every letter",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AA BR CU DH EQ FS GL IP JX KN MO TZ VV WY", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: reflector validation 3",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Reflector connects A more than once",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AY AR CU DH EQ FS GL IP JX KN MO TZ", // B
+                    ""
+                ]
+            }
+        ]
+    },
+    {
+        name: "Enigma: reflector validation 4",
+        input: "Hello, world. This is a test.",
+        expectedOutput: "Reflector must be a whitespace-separated list of uppercase letter pairs",
+        recipeConfig: [
+            {
+                "op": "Enigma",
+                "args": [
+                    "3-rotor",
+                    "", "A", "A",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R", "A", "A", // I
+                    "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "A", "A", // II
+                    "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "A", "A", // III
+                    "AYBR CU DH EQ FS GL IP JX KN MO TZ", // B
+                    ""
+                ]
+            }
+        ]
+    },
+]);

tests/operations/tests/MultipleBombe.mjs

@@ -0,0 +1,49 @@
+/**
+ * Bombe machine tests.
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import TestRegister from "../TestRegister";
+
+TestRegister.addTests([
+    {
+        name: "Multi-Bombe: 3 rotor",
+        input: "BBYFLTHHYIJQAYBBYS",
+        expectedMatch: /<td>LGA<\/td> {2}<td>SS<\/td> {2}<td>VFISUSGTKSTMPSUNAK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Multiple Bombe",
+                "args": [
+                    // I, II and III
+                    "User defined",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R\nAJDKSIRUXBLHWTMCQGZNPYFVOE<F\nBDFHJLCPRTXVZNYEIWGAKMUSQO<W",
+                    "",
+                    "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", // B
+                    "THISISATESTMESSAGE", 0, false
+                ]
+            }
+        ]
+    },
+    /*
+     * This is too slow to run regularly
+    {
+        name: "Multi-Bombe: 4 rotor",
+        input: "LUOXGJSHGEDSRDOQQX",
+        expectedMatch: /<td>LHSC<\/td><td>SS<\/td><td>HHHSSSGQUUQPKSEKWK<\/td>/,
+        recipeConfig: [
+            {
+                "op": "Multiple Bombe",
+                "args": [
+                    // I, II and III
+                    "User defined",
+                    "EKMFLGDQVZNTOWYHXUSPAIBRCJ<R\nAJDKSIRUXBLHWTMCQGZNPYFVOE<F\nBDFHJLCPRTXVZNYEIWGAKMUSQO<W",
+                    "LEYJVCNIXWPBQMDRTAKZGFUHOS", // Beta
+                    "AE BN CK DQ FU GY HW IJ LO MP RX SZ TV", // B thin
+                    "THISISATESTMESSAGE", 0, false
+                ]
+            }
+        ]
+    },
+    */
+]);

tests/operations/tests/Typex.mjs

@@ -0,0 +1,105 @@
+/**
+ * Typex machine tests.
+ * @author s2224834
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+import TestRegister from "../TestRegister";
+
+TestRegister.addTests([
+    {
+        // Unlike Enigma we're not verifying against a real machine here, so this is just a test
+        // to catch inadvertent breakage.
+        name: "Typex: basic",
+        input: "hello world, this is a test message.",
+        expectedOutput: "VIXQQ VHLPN UCVLA QDZNZ EAYAT HWC",
+        recipeConfig: [
+            {
+                "op": "Typex",
+                "args": [
+                    "MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW",
+                    false, "B", "C",
+                    "KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW",
+                    false, "D", "E",
+                    "BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW",
+                    false, "F", "G",
+                    "ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW",
+                    true, "H", "I",
+                    "QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW",
+                    true, "J", "K",
+                    "AN BC FG IE KD LU MH OR TS VZ WQ XJ YP",
+                    "EHZTLCVKFRPQSYANBUIWOJXGMD",
+                    "None", true
+                ]
+            }
+        ]
+    },
+    {
+        name: "Typex: keyboard",
+        input: "hello world, this is a test message.",
+        expectedOutput: "VIXQQ FDJXT WKLDQ DFQOD CNCSK NULBG JKQDD MVGQ",
+        recipeConfig: [
+            {
+                "op": "Typex",
+                "args": [
+                    "MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW",
+                    false, "B", "C",
+                    "KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW",
+                    false, "D", "E",
+                    "BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW",
+                    false, "F", "G",
+                    "ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW",
+                    true, "H", "I",
+                    "QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW",
+                    true, "J", "K",
+                    "AN BC FG IE KD LU MH OR TS VZ WQ XJ YP",
+                    "EHZTLCVKFRPQSYANBUIWOJXGMD",
+                    "Encrypt", true
+                ]
+            }
+        ]
+    },
+    {
+        name: "Typex: self-decrypt",
+        input: "hello world, this is a test message.",
+        expectedOutput: "HELLO WORLD, THIS IS A TEST MESSAGE.",
+        recipeConfig: [
+            {
+                "op": "Typex",
+                "args": [
+                    "MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW",
+                    false, "B", "C",
+                    "KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW",
+                    false, "D", "E",
+                    "BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW",
+                    false, "F", "G",
+                    "ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW",
+                    true, "H", "I",
+                    "QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW",
+                    true, "J", "K",
+                    "AN BC FG IE KD LU MH OR TS VZ WQ XJ YP",
+                    "EHZTLCVKFRPQSYANBUIWOJXGMD",
+                    "Encrypt", true
+                ]
+            },
+            {
+                "op": "Typex",
+                "args": [
+                    "MCYLPQUVRXGSAOWNBJEZDTFKHI<BFHNQUW",
+                    false, "B", "C",
+                    "KHWENRCBISXJQGOFMAPVYZDLTU<BFHNQUW",
+                    false, "D", "E",
+                    "BYPDZMGIKQCUSATREHOJNLFWXV<BFHNQUW",
+                    false, "F", "G",
+                    "ZANJCGDLVHIXOBRPMSWQUKFYET<BFHNQUW",
+                    true, "H", "I",
+                    "QXBGUTOVFCZPJIHSWERYNDAMLK<BFHNQUW",
+                    true, "J", "K",
+                    "AN BC FG IE KD LU MH OR TS VZ WQ XJ YP",
+                    "EHZTLCVKFRPQSYANBUIWOJXGMD",
+                    "Decrypt", true
+                ]
+            }
+        ]
+    },
+]);

webpack.config.js

@@ -100,8 +100,15 @@ module.exports = {
                     limit: 10000
                 }
             },
+            {
+                test: /\.svg$/,
+                loader: "svg-url-loader",
+                options: {
+                    encoding: "base64"
+                }
+            },
             { // First party images are saved as files to be cached
-                test: /\.(png|jpg|gif|svg)$/,
+                test: /\.(png|jpg|gif)$/,
                 exclude: /node_modules/,
                 loader: "file-loader",
                 options: {
@@ -109,7 +116,7 @@ module.exports = {
                 }
             },
             { // Third party images are inlined
-                test: /\.(png|jpg|gif|svg)$/,
+                test: /\.(png|jpg|gif)$/,
                 exclude: /web\/static/,
                 loader: "url-loader",
                 options: {