9.36.1

Closes #1219

Co-developed-by: Cyril Delétré <cyril.deletre@gmail.com>

CHANGELOG.md

@@ -13,6 +13,12 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.36.0] - 2022-03-29
+- 'SIGABA' operation added [@hettysymes] | [#934]
+
+### [9.35.0] - 2022-03-28
+- 'To Base45' and 'From Base45' operations added [@t-8ch] | [#1242]
+
 ### [9.34.0] - 2022-03-28
 - 'Get All Casings' operation added [@n1073645] | [#1065]
 
@@ -278,6 +284,8 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.36.0]: https://github.com/gchq/CyberChef/releases/tag/v9.36.0
+[9.35.0]: https://github.com/gchq/CyberChef/releases/tag/v9.35.0
 [9.34.0]: https://github.com/gchq/CyberChef/releases/tag/v9.34.0
 [9.33.0]: https://github.com/gchq/CyberChef/releases/tag/v9.33.0
 [9.32.0]: https://github.com/gchq/CyberChef/releases/tag/v9.32.0
@@ -395,6 +403,7 @@ All major and minor version changes will be documented in this file. Details of
 [@Danh4]: https://github.com/Danh4
 [@john19696]: https://github.com/john19696
 [@t-8ch]: https://github.com/t-8ch
+[@hettysymes]: https://github.com/hettysymes
 
 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
 [9a33498]: https://github.com/gchq/CyberChef/commit/9a33498fed26a8df9c9f35f39a78a174bf50a513
@@ -469,6 +478,7 @@ All major and minor version changes will be documented in this file. Details of
 [#865]: https://github.com/gchq/CyberChef/pull/865
 [#912]: https://github.com/gchq/CyberChef/pull/912
 [#917]: https://github.com/gchq/CyberChef/pull/917
+[#934]: https://github.com/gchq/CyberChef/pull/934
 [#948]: https://github.com/gchq/CyberChef/pull/948
 [#952]: https://github.com/gchq/CyberChef/pull/952
 [#965]: https://github.com/gchq/CyberChef/pull/965
@@ -482,6 +492,7 @@ All major and minor version changes will be documented in this file. Details of
 [#1049]: https://github.com/gchq/CyberChef/pull/1049
 [#1065]: https://github.com/gchq/CyberChef/pull/1065
 [#1083]: https://github.com/gchq/CyberChef/pull/1083
+[#1242]: https://github.com/gchq/CyberChef/pull/1242
 [#1244]: https://github.com/gchq/CyberChef/pull/1244
 [#1313]: https://github.com/gchq/CyberChef/pull/1313
 [#1326]: https://github.com/gchq/CyberChef/pull/1326

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cyberchef",
-  "version": "9.34.2",
+  "version": "9.36.1",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "cyberchef",
-      "version": "9.34.2",
+      "version": "9.36.1",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.34.2",
+  "version": "9.36.1",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",

src/core/Utils.mjs

@@ -1207,6 +1207,30 @@ class Utils {
         }[token];
     }
 
+    /**
+     * Iterate object in chunks of given size.
+     *
+     * @param {Iterable} iterable
+     * @param {number} chunksize
+     */
+    static* chunked(iterable, chunksize) {
+        const iterator = iterable[Symbol.iterator]();
+        while (true) {
+            const res = [];
+            for (let i = 0; i < chunksize; i++) {
+                const next = iterator.next();
+                if (next.done) {
+                    break;
+                }
+                res.push(next.value);
+            }
+            if (res.length) {
+                yield res;
+            } else {
+                return;
+            }
+        }
+    }
 }
 
 /**

src/core/config/Categories.json

@@ -20,6 +20,8 @@
             "From Octal",
             "To Base32",
             "From Base32",
+            "To Base45",
+            "From Base45",
             "To Base58",
             "From Base58",
             "To Base62",
@@ -118,7 +120,8 @@
             "Multiple Bombe",
             "Typex",
             "Lorenz",
-            "Colossus"
+            "Colossus",
+            "SIGABA"
         ]
     },
     {

src/core/lib/Base45.mjs

@@ -0,0 +1,27 @@
+/**
+ * Base45 resources.
+ *
+ * @author Thomas Weißschuh [thomas@t-8ch.de]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+/**
+ * Highlight to Base45
+ */
+export function highlightToBase45(pos, args) {
+    pos[0].start = Math.floor(pos[0].start / 2) * 3;
+    pos[0].end = Math.ceil(pos[0].end / 2) * 3;
+    return pos;
+}
+
+/**
+ * Highlight from Base45
+ */
+export function highlightFromBase45(pos, args) {
+    pos[0].start = Math.floor(pos[0].start / 3) * 2;
+    pos[0].end = Math.ceil(pos[0].end / 3) * 2;
+    return pos;
+}
+
+export const ALPHABET = "0-9A-Z $%*+\\-./:";

src/core/lib/Charts.mjs

@@ -6,6 +6,7 @@
  */
 
 import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
 
 /**
  * @constant
@@ -128,7 +129,7 @@ export function getScatterValuesWithColour(input, recordDelimiter, fieldDelimite
         if (Number.isNaN(x)) throw new OperationError("Values must be numbers in base 10.");
         if (Number.isNaN(y)) throw new OperationError("Values must be numbers in base 10.");
 
-        return [x, y, colour];
+        return [x, y, Utils.escapeHtml(colour)];
     });
 
     return { headings, values };

src/core/lib/SIGABA.mjs

@@ -0,0 +1,502 @@
+/**
+ * Emulation of the SIGABA machine
+ *
+ * @author hettysymes
+ * @copyright hettysymes 2020
+ * @license Apache-2.0
+ */
+
+/**
+ * A set of randomised example SIGABA cipher/control rotors (these rotors are interchangeable). Cipher and control rotors can be referred to as C and R rotors respectively.
+ */
+export const CR_ROTORS = [
+    {name: "Example 1", value: "SRGWANHPJZFXVIDQCEUKBYOLMT"},
+    {name: "Example 2", value: "THQEFSAZVKJYULBODCPXNIMWRG"},
+    {name: "Example 3", value: "XDTUYLEVFNQZBPOGIRCSMHWKAJ"},
+    {name: "Example 4", value: "LOHDMCWUPSTNGVXYFJREQIKBZA"},
+    {name: "Example 5", value: "ERXWNZQIJYLVOFUMSGHTCKPBDA"},
+    {name: "Example 6", value: "FQECYHJIOUMDZVPSLKRTGWXBAN"},
+    {name: "Example 7", value: "TBYIUMKZDJSOPEWXVANHLCFQGR"},
+    {name: "Example 8", value: "QZUPDTFNYIAOMLEBWJXCGHKRSV"},
+    {name: "Example 9", value: "CZWNHEMPOVXLKRSIDGJFYBTQAU"},
+    {name: "Example 10", value: "ENPXJVKYQBFZTICAGMOHWRLDUS"}
+];
+
+/**
+ * A set of randomised example SIGABA index rotors (may be referred to as I rotors).
+ */
+export const I_ROTORS = [
+    {name: "Example 1", value: "6201348957"},
+    {name: "Example 2", value: "6147253089"},
+    {name: "Example 3", value: "8239647510"},
+    {name: "Example 4", value: "7194835260"},
+    {name: "Example 5", value: "4873205916"}
+];
+
+export const NUMBERS = "0123456789".split("");
+
+/**
+ * Converts a letter to uppercase (if it already isn't)
+ *
+ * @param {char} letter - letter to convert to uppercase
+ * @returns {char}
+ */
+export function convToUpperCase(letter) {
+    const charCode = letter.charCodeAt();
+    if (97<=charCode && charCode<=122) {
+        return String.fromCharCode(charCode-32);
+    }
+    return letter;
+}
+
+/**
+ * The SIGABA machine consisting of the 3 rotor banks: cipher, control and index banks.
+ */
+export class SigabaMachine {
+
+    /**
+     * SigabaMachine constructor
+     *
+     * @param {Object[]} cipherRotors - list of CRRotors
+     * @param {Object[]} controlRotors - list of CRRotors
+     * @param {object[]} indexRotors - list of IRotors
+     */
+    constructor(cipherRotors, controlRotors, indexRotors) {
+        this.cipherBank = new CipherBank(cipherRotors);
+        this.controlBank = new ControlBank(controlRotors);
+        this.indexBank = new IndexBank(indexRotors);
+    }
+
+    /**
+     * Steps all the correct rotors in the machine.
+     */
+    step() {
+        const controlOut = this.controlBank.goThroughControl();
+        const indexOut = this.indexBank.goThroughIndex(controlOut);
+        this.cipherBank.step(indexOut);
+    }
+
+    /**
+     * Encrypts a letter. A space is converted to a "Z" before encryption, and a "Z" is converted to an "X". This allows spaces to be encrypted.
+     *
+     * @param {char} letter - letter to encrypt
+     * @returns {char}
+     */
+    encryptLetter(letter) {
+        letter = convToUpperCase(letter);
+        if (letter === " ") {
+            letter = "Z";
+        } else if (letter === "Z") {
+            letter = "X";
+        }
+        const encryptedLetter = this.cipherBank.encrypt(letter);
+        this.step();
+        return encryptedLetter;
+    }
+
+    /**
+     * Decrypts a letter. A letter decrypted as a "Z" is converted to a space before it is output, since spaces are converted to "Z"s before encryption.
+     *
+     * @param {char} letter - letter to decrypt
+     * @returns {char}
+     */
+    decryptLetter(letter) {
+        letter = convToUpperCase(letter);
+        let decryptedLetter = this.cipherBank.decrypt(letter);
+        if (decryptedLetter === "Z") {
+            decryptedLetter = " ";
+        }
+        this.step();
+        return decryptedLetter;
+    }
+
+    /**
+     * Encrypts a message of one or more letters
+     *
+     * @param {string} msg - message to encrypt
+     * @returns {string}
+     */
+    encrypt(msg) {
+        let ciphertext = "";
+        for (const letter of msg) {
+            ciphertext = ciphertext.concat(this.encryptLetter(letter));
+        }
+        return ciphertext;
+    }
+
+    /**
+     * Decrypts a message of one or more letters
+     *
+     * @param {string} msg - message to decrypt
+     * @returns {string}
+     */
+    decrypt(msg) {
+        let plaintext = "";
+        for (const letter of msg) {
+            plaintext = plaintext.concat(this.decryptLetter(letter));
+        }
+        return plaintext;
+    }
+
+}
+
+/**
+ * The cipher rotor bank consists of 5 cipher rotors in either a forward or reversed orientation.
+ */
+export class CipherBank {
+
+    /**
+     * CipherBank constructor
+     *
+     * @param {Object[]} rotors - list of CRRotors
+     */
+    constructor(rotors) {
+        this.rotors = rotors;
+    }
+
+    /**
+     * Encrypts a letter through the cipher rotors (signal goes from left-to-right)
+     *
+     * @param {char} inputPos - the input position of the signal (letter to be encrypted)
+     * @returns {char}
+     */
+    encrypt(inputPos) {
+        for (const rotor of this.rotors) {
+            inputPos = rotor.crypt(inputPos, "leftToRight");
+        }
+        return inputPos;
+    }
+
+    /**
+     * Decrypts a letter through the cipher rotors (signal goes from right-to-left)
+     *
+     * @param {char} inputPos - the input position of the signal (letter to be decrypted)
+     * @returns {char}
+     */
+    decrypt(inputPos) {
+        const revOrderedRotors = [...this.rotors].reverse();
+        for (const rotor of revOrderedRotors) {
+            inputPos = rotor.crypt(inputPos, "rightToLeft");
+        }
+        return inputPos;
+    }
+
+    /**
+     * Step the cipher rotors forward according to the inputs from the index rotors
+     *
+     * @param {number[]} indexInputs - the inputs from the index rotors
+     */
+    step(indexInputs) {
+        const logicDict = {0: [0, 9], 1: [7, 8], 2: [5, 6], 3: [3, 4], 4: [1, 2]};
+        const rotorsToMove = [];
+        for (const key in logicDict) {
+            const item = logicDict[key];
+            for (const i of indexInputs) {
+                if (item.includes(i)) {
+                    rotorsToMove.push(this.rotors[key]);
+                    break;
+                }
+            }
+        }
+        for (const rotor of rotorsToMove) {
+            rotor.step();
+        }
+    }
+
+}
+
+/**
+ * The control rotor bank consists of 5 control rotors in either a forward or reversed orientation. Signals to the control rotor bank always go from right-to-left.
+ */
+export class ControlBank {
+
+    /**
+     * ControlBank constructor. The rotors have been reversed as signals go from right-to-left through the control rotors.
+     *
+     * @param {Object[]} rotors - list of CRRotors
+     */
+    constructor(rotors) {
+        this.rotors = [...rotors].reverse();
+    }
+
+    /**
+     * Encrypts a letter.
+     *
+     * @param {char} inputPos - the input position of the signal
+     * @returns {char}
+     */
+    crypt(inputPos) {
+        for (const rotor of this.rotors) {
+            inputPos = rotor.crypt(inputPos, "rightToLeft");
+        }
+        return inputPos;
+    }
+
+    /**
+     * Gets the outputs of the control rotors. The inputs to the control rotors are always "F", "G", "H" and "I".
+     *
+     * @returns {number[]}
+     */
+    getOutputs() {
+        const outputs = [this.crypt("F"), this.crypt("G"), this.crypt("H"), this.crypt("I")];
+        const logicDict = {1: "B", 2: "C", 3: "DE", 4: "FGH", 5: "IJK", 6: "LMNO", 7: "PQRST", 8: "UVWXYZ", 9: "A"};
+        const numberOutputs = [];
+        for (const key in logicDict) {
+            const item = logicDict[key];
+            for (const output of outputs) {
+                if (item.includes(output)) {
+                    numberOutputs.push(key);
+                    break;
+                }
+            }
+        }
+        return numberOutputs;
+    }
+
+    /**
+     * Steps the control rotors. Only 3 of the control rotors step: one after every encryption, one after every 26, and one after every 26 squared.
+     */
+    step() {
+        const MRotor = this.rotors[1], FRotor = this.rotors[2], SRotor = this.rotors[3];
+        // 14 is the offset of "O" from "A" - the next rotor steps once the previous rotor reaches "O"
+        if (FRotor.state === 14) {
+            if (MRotor.state === 14) {
+                SRotor.step();
+            }
+            MRotor.step();
+        }
+        FRotor.step();
+    }
+
+    /**
+     * The goThroughControl function combines getting the outputs from the control rotor bank and then stepping them.
+     *
+     * @returns {number[]}
+     */
+    goThroughControl() {
+        const outputs = this.getOutputs();
+        this.step();
+        return outputs;
+    }
+
+}
+
+/**
+ * The index rotor bank consists of 5 index rotors all placed in the forwards orientation.
+ */
+export class IndexBank {
+
+    /**
+     * IndexBank constructor
+     *
+     * @param {Object[]} rotors - list of IRotors
+     */
+    constructor(rotors) {
+        this.rotors = rotors;
+    }
+
+    /**
+     * Encrypts a number.
+     *
+     * @param {number} inputPos - the input position of the signal
+     * @returns {number}
+     */
+    crypt(inputPos) {
+        for (const rotor of this.rotors) {
+            inputPos = rotor.crypt(inputPos);
+        }
+        return inputPos;
+    }
+
+    /**
+     * The goThroughIndex function takes the inputs from the control rotor bank and returns the list of outputs after encryption through the index rotors.
+     *
+     * @param {number[]} controlInputs - inputs from the control rotors
+     * @returns {number[]}
+     */
+    goThroughIndex(controlInputs) {
+        const outputs = [];
+        for (const inp of controlInputs) {
+            outputs.push(this.crypt(inp));
+        }
+        return outputs;
+    }
+
+}
+
+/**
+ * Rotor class
+ */
+export class Rotor {
+
+    /**
+     * Rotor constructor
+     *
+     * @param {number[]} wireSetting - the wirings within the rotor: mapping from left-to-right, the index of the number in the list maps onto the number at that index
+     * @param {bool} rev - true if the rotor is reversed, false if it isn't
+     * @param {number} key - the starting position or state of the rotor
+     */
+    constructor(wireSetting, key, rev) {
+        this.state = key;
+        this.numMapping = this.getNumMapping(wireSetting, rev);
+        this.posMapping = this.getPosMapping(rev);
+    }
+
+    /**
+     * Get the number mapping from the wireSetting (only different from wireSetting if rotor is reversed)
+     *
+     * @param {number[]} wireSetting - the wirings within the rotors
+     * @param {bool} rev - true if reversed, false if not
+     * @returns {number[]}
+     */
+    getNumMapping(wireSetting, rev) {
+        if (rev===false) {
+            return wireSetting;
+        } else {
+            const length = wireSetting.length;
+            const tempMapping = new Array(length);
+            for (let i=0; i<length; i++) {
+                tempMapping[wireSetting[i]] = i;
+            }
+            return tempMapping;
+        }
+    }
+
+    /**
+     * Get the position mapping (how the position numbers map onto the numbers of the rotor)
+     *
+     * @param {bool} rev - true if reversed, false if not
+     * @returns {number[]}
+     */
+    getPosMapping(rev) {
+        const length = this.numMapping.length;
+        const posMapping = [];
+        if (rev===false) {
+            for (let i = this.state; i < this.state+length; i++) {
+                let res = i%length;
+                if (res<0) {
+                    res += length;
+                }
+                posMapping.push(res);
+            }
+        } else {
+            for (let i = this.state; i > this.state-length; i--) {
+                let res = i%length;
+                if (res<0) {
+                    res += length;
+                }
+                posMapping.push(res);
+            }
+        }
+        return posMapping;
+    }
+
+    /**
+     * Encrypt/decrypt data. This process is identical to the rotors of cipher machines such as Enigma or Typex.
+     *
+     * @param {number} inputPos - the input position of the signal (the data to encrypt/decrypt)
+     * @param {string} direction - one of "leftToRight" and "rightToLeft", states the direction in which the signal passes through the rotor
+     * @returns {number}
+     */
+    cryptNum(inputPos, direction) {
+        const inpNum = this.posMapping[inputPos];
+        let outNum;
+        if (direction === "leftToRight") {
+            outNum = this.numMapping[inpNum];
+        } else if (direction === "rightToLeft") {
+            outNum = this.numMapping.indexOf(inpNum);
+        }
+        const outPos = this.posMapping.indexOf(outNum);
+        return outPos;
+    }
+
+    /**
+     * Steps the rotor. The number at position 0 will be moved to position 1 etc.
+     */
+    step() {
+        const lastNum = this.posMapping.pop();
+        this.posMapping.splice(0, 0, lastNum);
+        this.state = this.posMapping[0];
+    }
+
+}
+
+/**
+ * A CRRotor is a cipher (C) or control (R) rotor. These rotors are identical and interchangeable. A C or R rotor consists of 26 contacts, one for each letter, and may be put into either a forwards of reversed orientation.
+ */
+export class CRRotor extends Rotor {
+
+    /**
+     * CRRotor constructor
+     *
+     * @param {string} wireSetting - the rotor wirings (string of letters)
+     * @param {char} key - initial state of rotor
+     * @param {bool} rev - true if reversed, false if not
+     */
+    constructor(wireSetting, key, rev=false) {
+        wireSetting = wireSetting.split("").map(CRRotor.letterToNum);
+        super(wireSetting, CRRotor.letterToNum(key), rev);
+    }
+
+    /**
+     * Static function which converts a letter into its number i.e. its offset from the letter "A"
+     *
+     * @param {char} letter - letter to convert to number
+     * @returns {number}
+     */
+    static letterToNum(letter) {
+        return letter.charCodeAt()-65;
+    }
+
+    /**
+     * Static function which converts a number (a letter's offset from "A") into its letter
+     *
+     * @param {number} num - number to convert to letter
+     * @returns {char}
+     */
+    static numToLetter(num) {
+        return String.fromCharCode(num+65);
+    }
+
+    /**
+     * Encrypts/decrypts a letter.
+     *
+     * @param {char} inputPos - the input position of the signal ("A" refers to position 0 etc.)
+     * @param {string} direction - one of "leftToRight" and "rightToLeft"
+     * @returns {char}
+     */
+    crypt(inputPos, direction) {
+        inputPos = CRRotor.letterToNum(inputPos);
+        const outPos = this.cryptNum(inputPos, direction);
+        return CRRotor.numToLetter(outPos);
+    }
+
+}
+
+/**
+ * An IRotor is an index rotor, which consists of 10 contacts each numbered from 0 to 9. Unlike C and R rotors, they cannot be put in the reversed orientation. The index rotors do not step at any point during encryption or decryption.
+ */
+export class IRotor extends Rotor {
+
+    /**
+     * IRotor constructor
+     *
+     * @param {string} wireSetting - the rotor wirings (string of numbers)
+     * @param {char} key - initial state of rotor
+     */
+    constructor(wireSetting, key) {
+        wireSetting = wireSetting.split("").map(Number);
+        super(wireSetting, Number(key), false);
+    }
+
+    /**
+     * Encrypts a number
+     *
+     * @param {number} inputPos - the input position of the signal
+     * @returns {number}
+     */
+    crypt(inputPos) {
+        return this.cryptNum(inputPos, "leftToRight");
+    }
+
+}

src/core/operations/Bombe.mjs

@@ -1,6 +1,9 @@
 /**
  * Emulation of the Bombe machine.
  *
+ * Tested against the Bombe Rebuild at Bletchley Park's TNMOC
+ * using a variety of inputs and settings to confirm correctness.
+ *
  * @author s2224834
  * @copyright Crown Copyright 2019
  * @license Apache-2.0

src/core/operations/Colossus.mjs

@@ -1,6 +1,9 @@
 /**
  * Emulation of Colossus.
  *
+ * Tested against the Colossus Rebuild at Bletchley Park's TNMOC
+ * using a variety of inputs and settings to confirm correctness.
+ *
  * @author VirtualColossus [martin@virtualcolossus.co.uk]
  * @copyright Crown Copyright 2019
  * @license Apache-2.0

src/core/operations/Enigma.mjs

@@ -1,6 +1,9 @@
 /**
  * Emulation of the Enigma machine.
  *
+ * Tested against various genuine Enigma machines using a variety of inputs
+ * and settings to confirm correctness.
+ *
  * @author s2224834
  * @copyright Crown Copyright 2019
  * @license Apache-2.0

src/core/operations/FromBase45.mjs

@@ -0,0 +1,89 @@
+/**
+ * @author Thomas Weißschuh [thomas@t-8ch.de]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import {ALPHABET, highlightToBase45, highlightFromBase45} from "../lib/Base45.mjs";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+
+
+/**
+ * From Base45 operation
+ */
+class FromBase45 extends Operation {
+
+    /**
+     * FromBase45 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Base45";
+        this.module = "Default";
+        this.description = "Base45 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system. Base45 is optimized for usage with QR codes.";
+        this.infoURL = "https://wikipedia.org/wiki/List_of_numeral_systems";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                name: "Alphabet",
+                type: "string",
+                value: ALPHABET
+            }
+        ];
+
+        this.highlight = highlightFromBase45;
+        this.highlightReverse = highlightToBase45;
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        if (!input) return [];
+        const alphabet = Utils.expandAlphRange(args[0]);
+
+        const res = [];
+
+        for (const triple of Utils.chunked(input, 3)) {
+            triple.reverse();
+            let b = 0;
+            for (const c of triple) {
+                const idx = alphabet.indexOf(c);
+                if (idx === -1) {
+                    throw new OperationError(`Character not in alphabet: '${c}'`);
+                }
+                b *= 45;
+                b += idx;
+            }
+
+            if (b > 65535) {
+                throw new OperationError(`Triplet too large: '${triple.join("")}'`);
+            }
+
+            if (triple.length > 2) {
+                /**
+                 * The last triple may only have 2 bytes so we push the MSB when we got 3 bytes
+                 * Pushing MSB
+                 */
+                res.push(b >> 8);
+            }
+
+            /**
+             * Pushing LSB
+             */
+            res.push(b & 0xff);
+
+        }
+
+        return res;
+    }
+
+}
+
+export default FromBase45;

src/core/operations/GetAllCasings.mjs

@@ -46,7 +46,7 @@ class GetAllCasings extends Operation {
             }
             result += temp.join("") + "\n";
         }
-        return result;
+        return result.slice(0, -1);
     }
 }
 

src/core/operations/Lorenz.mjs

@@ -1,6 +1,9 @@
 /**
  * Emulation of the Lorenz SZ40/42a/42b cipher attachment.
  *
+ * Tested against the Colossus Rebuild at Bletchley Park's TNMOC
+ * using a variety of inputs and settings to confirm correctness.
+ *
  * @author VirtualColossus [martin@virtualcolossus.co.uk]
  * @copyright Crown Copyright 2019
  * @license Apache-2.0

src/core/operations/SIGABA.mjs

@@ -0,0 +1,287 @@
+/**
+ * Emulation of the SIGABA machine.
+ *
+ * @author hettysymes
+ * @copyright hettysymes 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {LETTERS} from "../lib/Enigma.mjs";
+import {NUMBERS, CR_ROTORS, I_ROTORS, SigabaMachine, CRRotor, IRotor} from "../lib/SIGABA.mjs";
+
+/**
+ * Sigaba operation
+ */
+class Sigaba extends Operation {
+
+    /**
+     * Sigaba constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "SIGABA";
+        this.module = "Bletchley";
+        this.description = "Encipher/decipher with the WW2 SIGABA machine. <br><br>SIGABA, otherwise known as ECM Mark II, was used by the United States for message encryption during WW2 up to the 1950s. It was developed in the 1930s by the US Army and Navy, and has up to this day never been broken. Consisting of 15 rotors: 5 cipher rotors and 10 rotors (5 control rotors and 5 index rotors) controlling the stepping of the cipher rotors, the rotor stepping for SIGABA is much more complex than other rotor machines of its time, such as Enigma. All example rotor wirings are random example sets.<br><br>To configure rotor wirings, for the cipher and control rotors enter a string of letters which map from A to Z, and for the index rotors enter a sequence of numbers which map from 0 to 9. Note that encryption is not the same as decryption, so first choose the desired mode. <br><br> Note: Whilst this has been tested against other software emulators, it has not been tested against hardware.";
+        this.infoURL = "https://wikipedia.org/wiki/SIGABA";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "1st (left-hand) cipher rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "1st cipher rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "1st cipher rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "2nd cipher rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "2nd cipher rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "2nd cipher rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "3rd (middle) cipher rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "3rd cipher rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "3rd cipher rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "4th cipher rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "4th cipher rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "4th cipher rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "5th (right-hand) cipher rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "5th cipher rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "5th cipher rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "1st (left-hand) control rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "1st control rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "1st control rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "2nd control rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "2nd control rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "2nd control rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "3rd (middle) control rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "3rd control rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "3rd control rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "4th control rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "4th control rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "4th control rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "5th (right-hand) control rotor",
+                type: "editableOption",
+                value: CR_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "5th control rotor reversed",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "5th control rotor intial value",
+                type: "option",
+                value: LETTERS
+            },
+            {
+                name: "1st (left-hand) index rotor",
+                type: "editableOption",
+                value: I_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "1st index rotor intial value",
+                type: "option",
+                value: NUMBERS
+            },
+            {
+                name: "2nd index rotor",
+                type: "editableOption",
+                value: I_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "2nd index rotor intial value",
+                type: "option",
+                value: NUMBERS
+            },
+            {
+                name: "3rd (middle) index rotor",
+                type: "editableOption",
+                value: I_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "3rd index rotor intial value",
+                type: "option",
+                value: NUMBERS
+            },
+            {
+                name: "4th index rotor",
+                type: "editableOption",
+                value: I_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "4th index rotor intial value",
+                type: "option",
+                value: NUMBERS
+            },
+            {
+                name: "5th (right-hand) index rotor",
+                type: "editableOption",
+                value: I_ROTORS,
+                defaultIndex: 0
+            },
+            {
+                name: "5th index rotor intial value",
+                type: "option",
+                value: NUMBERS
+            },
+            {
+                name: "SIGABA mode",
+                type: "option",
+                value: ["Encrypt", "Decrypt"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const sigabaSwitch = args[40];
+        const cipherRotors = [];
+        const controlRotors = [];
+        const indexRotors = [];
+        for (let i=0; i<5; i++) {
+            const rotorWiring = args[i*3];
+            cipherRotors.push(new CRRotor(rotorWiring, args[i*3+2], args[i*3+1]));
+        }
+        for (let i=5; i<10; i++) {
+            const rotorWiring = args[i*3];
+            controlRotors.push(new CRRotor(rotorWiring, args[i*3+2], args[i*3+1]));
+        }
+        for (let i=15; i<20; i++) {
+            const rotorWiring = args[i*2];
+            indexRotors.push(new IRotor(rotorWiring, args[i*2+1]));
+        }
+        const sigaba = new SigabaMachine(cipherRotors, controlRotors, indexRotors);
+        let result;
+        if (sigabaSwitch === "Encrypt") {
+            result = sigaba.encrypt(input);
+        } else if (sigabaSwitch === "Decrypt") {
+            result = sigaba.decrypt(input);
+        }
+        return result;
+    }
+
+}
+export default Sigaba;

src/core/operations/ScatterChart.mjs

@@ -87,7 +87,7 @@ class ScatterChart extends Operation {
         const recordDelimiter = Utils.charRep(args[0]),
             fieldDelimiter = Utils.charRep(args[1]),
             columnHeadingsAreIncluded = args[2],
-            fillColour = args[5],
+            fillColour = Utils.escapeHtml(args[5]),
             radius = args[6],
             colourInInput = args[7],
             dimension = 500;

src/core/operations/SeriesChart.mjs

@@ -72,7 +72,10 @@ class SeriesChart extends Operation {
             fieldDelimiter = Utils.charRep(args[1]),
             xLabel = args[2],
             pipRadius = args[3],
-            seriesColours = args[4].split(","),
+            // Escape HTML from all colours to prevent reflected XSS. See https://github.com/gchq/CyberChef/issues/1265
+            seriesColours = args[4].split(",").map((colour) => {
+                return Utils.escapeHtml(colour);
+            }),
             svgWidth = 500,
             interSeriesPadding = 20,
             xAxisHeight = 50,

src/core/operations/ToBase45.mjs

@@ -0,0 +1,78 @@
+/**
+ * @author Thomas Weißschuh [thomas@t-8ch.de]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import {ALPHABET, highlightToBase45, highlightFromBase45} from "../lib/Base45.mjs";
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * To Base45 operation
+ */
+class ToBase45 extends Operation {
+
+    /**
+     * ToBase45 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "To Base45";
+        this.module = "Default";
+        this.description = "Base45 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers. The high number base results in shorter strings than with the decimal or hexadecimal system. Base45 is optimized for usage with QR codes.";
+        this.infoURL = "https://wikipedia.org/wiki/List_of_numeral_systems";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Alphabet",
+                type: "string",
+                value: ALPHABET
+            }
+        ];
+
+        this.highlight = highlightToBase45;
+        this.highlightReverse = highlightFromBase45;
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        input = new Uint8Array(input);
+        const alphabet = Utils.expandAlphRange(args[0]);
+        if (!input) return "";
+
+        const res = [];
+
+        for (const pair of Utils.chunked(input, 2)) {
+            let b = 0;
+            for (const e of pair) {
+                b *= 256;
+                b += e;
+            }
+
+            let chars = 0;
+            do {
+                res.push(alphabet[b % 45]);
+                chars++;
+                b = Math.floor(b / 45);
+            } while (b > 0);
+
+            if (chars < 2) {
+                res.push("0");
+            }
+        }
+
+
+        return res.join("");
+
+    }
+
+}
+
+export default ToBase45;

src/core/operations/Typex.mjs

@@ -1,6 +1,9 @@
 /**
  * Emulation of the Typex machine.
  *
+ * Tested against a genuine Typex machine using a variety of inputs
+ * and settings to confirm correctness.
+ *
  * @author s2224834
  * @copyright Crown Copyright 2019
  * @license Apache-2.0

tests/operations/index.mjs

@@ -20,6 +20,7 @@ import TestRegister from "../lib/TestRegister.mjs";
 import "./tests/BCD.mjs";
 import "./tests/BSON.mjs";
 import "./tests/BaconCipher.mjs";
+import "./tests/Base45.mjs";
 import "./tests/Base58.mjs";
 import "./tests/Base64.mjs";
 import "./tests/Base62.mjs";
@@ -108,6 +109,8 @@ import "./tests/JA3Fingerprint.mjs";
 import "./tests/JA3SFingerprint.mjs";
 import "./tests/HASSH.mjs";
 import "./tests/GetAllCasings.mjs";
+import "./tests/SIGABA.mjs";
+
 
 // Cannot test operations that use the File type yet
 // import "./tests/SplitColourChannels.mjs";

tests/operations/tests/Base45.mjs

@@ -0,0 +1,103 @@
+/**
+ * Base45 tests.
+ *
+ * @author Thomas Weißschuh [thomas@t-8ch.de]
+ *
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+const defaultB45Alph = "0-9A-Z $%*+\\-./:";
+
+TestRegister.addTests([
+    {
+        name: "To Base45: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "To Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "To Base45: Spec encoding example 1",
+        input: "AB",
+        expectedOutput: "BB8",
+        recipeConfig: [
+            {
+                op: "To Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "To Base45: Spec encoding example 2",
+        input: "Hello!!",
+        expectedOutput: "%69 VD92EX0",
+        recipeConfig: [
+            {
+                op: "To Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "To Base45: Spec encoding example 3",
+        input: "base-45",
+        expectedOutput: "UJCLQE7W581",
+        recipeConfig: [
+            {
+                op: "To Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "From Base45: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "From Base45: Spec decoding example 1",
+        input: "QED8WEX0",
+        expectedOutput: "ietf!",
+        recipeConfig: [
+            {
+                op: "From Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "From Base45: Invalid character",
+        input: "!",
+        expectedOutput: "Character not in alphabet: '!'",
+        recipeConfig: [
+            {
+                op: "From Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+    {
+        name: "From Base45: Invalid triplet value",
+        input: "ZZZ",
+        expectedOutput: "Triplet too large: 'ZZZ'",
+        recipeConfig: [
+            {
+                op: "From Base45",
+                args: [defaultB45Alph],
+            },
+        ],
+    },
+]);

tests/operations/tests/GetAllCasings.mjs

@@ -11,7 +11,7 @@ TestRegister.addTests([
     {
         name: "All casings of test",
         input: "test",
-        expectedOutput: "test\nTest\ntEst\nTEst\nteSt\nTeSt\ntESt\nTESt\ntesT\nTesT\ntEsT\nTEsT\nteST\nTeST\ntEST\nTEST\n",
+        expectedOutput: "test\nTest\ntEst\nTEst\nteSt\nTeSt\ntESt\nTESt\ntesT\nTesT\ntEsT\nTEsT\nteST\nTeST\ntEST\nTEST",
         recipeConfig: [
             {
                 "op": "Get All Casings",
@@ -22,7 +22,7 @@ TestRegister.addTests([
     {
         name: "All casings of t",
         input: "t",
-        expectedOutput: "t\nT\n",
+        expectedOutput: "t\nT",
         recipeConfig: [
             {
                 "op": "Get All Casings",
@@ -33,7 +33,7 @@ TestRegister.addTests([
     {
         name: "All casings of null",
         input: "",
-        expectedOutput: "\n",
+        expectedOutput: "",
         recipeConfig: [
             {
                 "op": "Get All Casings",

tests/operations/tests/SIGABA.mjs

@@ -0,0 +1,91 @@
+/**
+ * SIGABA machine tests
+ *
+ * @author hettysymes
+ * @copyright hettysymes 2020
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "SIGABA: encrypt test 1",
+        input: "HELLO WORLD TESTING THE SIGABA MACHINE",
+        expectedOutput: "ULBECJCZJBJFVUDWAVRGRBMPSQHOTTNVQEESKN",
+        recipeConfig: [
+            {
+                "op": "SIGABA",
+                "args": [
+                    "BHKWECJDOVAYLFMITUGXRNSPZQ", true, "G",
+                    "CDTAKGQOZXLVJYHSWMIBPRUNEF", false, "L",
+                    "WAXHJZMBVDPOLTUYRCQFNSGKEI", false, "I",
+                    "HUSCWIMJQXDALVGBFTOYZKRPNE", false, "T",
+                    "RTLSMNKXFVWQUZGCHEJBYDAIPO", false, "B",
+                    "GHAQBRJWDMNZTSKLOUXYPFIECV", false, "N",
+                    "VFLGEMTCXZIQDYAKRPBONHWSUJ", true, "Q",
+                    "ZQCAYHRJNXPFLKIOTBUSVWMGDE", false, "B",
+                    "EZVSWPCTULGAOFDJNBIYMXKQHR", false, "J",
+                    "ELKSGDXMVYJUZNCAROQBPWHITF", false, "R",
+                    "3891625740", "3",
+                    "6297135408", "1",
+                    "2389715064", "8",
+                    "9264351708", "6",
+                    "9573086142", "6",
+                    "Encrypt"
+                ]
+            }
+        ]
+    },
+    {
+        name: "SIGABA: encrypt test 2",
+        input: "PCRPJZWSPNOHMWANBFBEIVZOXDQESPYDEFBNTHXLSICIRPKUATJVDUQFLZOKGHHHDUDIBRKUHVCGAGLBWVGFFXNDHKPFSPSCIIPCXUFRRHNYWIJFEJWQSGMSNJHWSLPKVXHUQUWIURHDIHIUTWGQFIYLTKEZAUESWYEKIWXUSSXWXBEHCXCUDQWKCISVPKXJVPOIJZWTUGKAORBMKBAQUZOPTSUSYZRROWQUYKNCLHVIHEGWCCONGVHEKCEXVYIPNILIXTXDELNGLJGMEQKKQJWZLPNXPOGIOSVAEAJYKWYJXXGKKPLVYAZGDCMNHMPLCYWDQSRBEMVVVZVFYJMRYGHJOTDOEQVRQOVXOGOVYGTXETFHAYELRYVDGWOFVGAOWPMHQYRZMNXVTAHWSKZLJDFVQPZGMHZWFNOBHSZHEDAEXIFCEEJYZDOEFOQWCXTKPJRUEITKHVCITCLKBUFNAFBYXELAYPBRGGGOCCAGLXXJXTSWCJHMHQPVUIBAGBDKAGEEEPKRGGICJQXSYHBNNAKGYODRAUWAEYHWCKHEQIBAONWQJYQCIFKDTOCTJMBJULWKMSNNMPXINHZQWUMJQLQKIPVZVRGYPCJJZMENWTFTUSPCSPRXHMZPCHCNQTUDCOUJHRKYQIUWWVEVVRYFDIYRQISNGPMQLNMCNMVBEWHNCUODHAGEVEUMKVZLEIKYAMPGVVSBYNRJMFCATDXTQCYXIBCXXKYEYHHYERQGQWZTWCEJBFQLRFFCIVVSZUKGLOTLNGLQNTIKTBBWVFMONUFKRLCJASEKUEEDDQDIVQMFRSJRNHYZJODFHSCJSDAIRUXOSDNFUFUFMNZYQIEGRUXKUPCHENUEZHRKYHDRJYSHLZNYRBWVXORMJMJRIRNSAJQRUMPCXUDFYRGKEAXQXJHPEWNIYIDURDGWIFEMSOFYYCFRZGMZXJNTLTJBBSZIULQSOMEVGCTCVXUHTIEHSPOPQYCJLPAJAPQPAQXE",
+        expectedOutput: "GMEXPPCMFGKUVGXZHVTCKXRSTJUYWNOKFVELWAHHSJBXGOEXCMLOVSIMCDMGEYMWWTFDUMCDUJEZITNPVVBGQDJEVHJXSKJAAUZWBELMSPUTXCUYPDTJCQXEBGWPWRSQLSNFMASCTJZDSFNKDDTAXLRGUPKCBNXMZPADJSFGGNYKRPYBNTYPTGVPACBEINILNACWFVKMJPGCEZFROEYYKTGYSQYMFSGVDOJJONNYEYSCCIXWLKUSJZDRVAQSNUWHMDJVDNNMPGOYRGQRSBGSPQKGCTFZQWSOXBWSQZDCRQJQAWZDPQEILGMMABIMCDPNSKAFCLPQGIRJCMGQREBEUHBYREXFABFMVZTZBDUMASVNUMHIYRSZLGNZFMVAIABLCUZLJLKKZPWEXDHYZFVSNRLCLNDRKLKSWRHQVQJRTHCNFZXDEXSLAXXOGMFVSGCJGAWOLGDMTLWSFNTCUVCCEACINRZAZZOGLEHHXLPHVKILBBJDPOOCILQKKGODSXOBDPZZDXHJLLBOBVFCHJVMUBUZZIKGCWGCYGXVEHHIJGPEQERWEZLILQNHPHALFKFMGADNELGBKILKIUETGDCBQUEOECWVFNOXTJKUYPWBNEKYSIKMVSAMBZGLIKDAOELRSTKFASEKABTUCPSFEGXXQGDFPSPVOLBHGLZSLLWCABSRKZDQQRKVCKXDGTIHPDNMPDZEXYFYKXZTPJPLYOFNLWAGKJEOHOYLMZELXIDWWNXPKEPUCKNNNHJLFYHPQNHMMCGMUPHSUSYYIVWTIMFKKKTFPGFTLTWWSQBRBMGBTZXPVULKNZIIKVTYLJFISGPTLZFTCLGNZOMVKZOIMUDGXRDDSVFRHRYWBEWHYLCUISYMRWAZZAQPJYXZQQKZLILOSHXUTQJFPTXQSREKSUDZTLGUDLUGOJMQHJRJHXCHQTKJULTWWQOXIRFRQEYBPJPEKXFIRMNATWNFBADOSIJVZYRYDBHDAEDJUVDHLDAU",
+        recipeConfig: [
+            { "op": "SIGABA",
+                "args": [
+                    "YCHLQSUGBDIXNZKERPVJTAWFOM", true, "A",
+                    "INPXBWETGUYSAOCHVLDMQKZJFR", false, "B",
+                    "WNDRIOZPTAXHFJYQBMSVEKUCGL", false, "C",
+                    "TZGHOBKRVUXLQDMPNFWCJYEIAS", false, "D",
+                    "YWTAHRQJVLCEXUNGBIPZMSDFOK", true, "E",
+                    "QSLRBTEKOGAICFWYVMHJNXZUDP", false, "F",
+                    "CHJDQIGNBSAKVTUOXFWLEPRMZY", false, "G",
+                    "CDFAJXTIMNBEQHSUGRYLWZKVPO", true, "H",
+                    "XHFESZDNRBCGKQIJLTVMUOYAPW", false, "I",
+                    "EZJQXMOGYTCSFRIUPVNADLHWBK", false, "J",
+                    "7591482630", "0",
+                    "3810592764", "1",
+                    "4086153297", "2",
+                    "3980526174", "3",
+                    "6497135280", "4",
+                    "Encrypt"]
+            }
+        ]
+    },
+    {
+        name: "SIGABA: decrypt test",
+        input: "AKDHFWAYSLHJDKXEVMJJHGKFTQBZPJPJILOVHMBYOAGBZVLLTQUOIKXFPUFNILBDPCAELMAPSXTLMUEGSDTNUDWGZDADBFELWWHKVPRZNDATDPYEHIDMTGAGPDEZYXFSASVKSBMXVOJQXRMHDBWUNZDTIIIVKHJYPIEUHAJCNBXNLGVFADEWIKXDJZBUTGOQBCQZWYKRVEENWRWWRYDNOAPGMODTPTUJZCLUCRDILJABNTBTWUEIJSJRQBUVCOUJJDWFMNNUHXBDFYXLGUMXQEAWSVHBXQGEOOGPYRVOAJLAIYIOHHEXACDTAWWCBGQRNPERSIKHTXPXKBUNACZLFZTRBMBBDDGKNBIQMFHZROCZZBGNZSJKDRRWPEQHLCFADNPWPWSLPIFNKBWQPMARUERGWUUODXSCOJQECGHIZRFRNRSXWSFWKISHHTUFRVXLHCQWGBMRDHCYDSVNIDDRSTODCGJSSBLUYOBGEWFOVKOZBJTYCAKMZECUGLJGTSZJNBOLTMUZRRSIGGRQHLRPMGLINASSMZOBNACKUMSFNIZAUFCPFXXOOTJQWWLZOFLGZLHJCWZJCRJKVOUDLNMKQATGVTOFHACAEKFLRWRTTMVRXHYGOTYPNBMUSKDAKXFCICUOVSWXGPQOYUUWTWRPQMEQCSDJMMJKELIHGEDYKWOVHVPUAIBFGAODXODXVFIIZIGWRZSBTIGXVHFABMMOPGVMLGHQQXNOEJRDLOBGUOWSELBHERZFSBLUODMOGIBNVGVGQYDBTKLOPNKZZNGLTTGZYYXIBAHZJDCILZXKNSJDHXWTYQLFHTUINTYSBPIXOPLOQHSAHGQPYUWYNPKMRBBBYIICCBBJRKWVLBIDBBEKJCXHLPUBMIGBUFYDPOCSRUNZOKMKJHMYFJZWFNHQZOGGRTNNUVLMRLDSAJIECTYCJKBYVNAXGCMGNVFJEDSATZQDQTYRBPLZKHAXMOVJZEDKINXKBUVWXXHTYUFO",
+        expectedOutput: "KTSOYDGMLPMVXEAJIATXCNQFXHBNCBXIJOCQGCQBRQSBYFOOEVPVXACBMIUIRNVMJHREKRHBSXJFSMWCKTTCYXJOFSJCQECXXCHTEGPEYSMYDHCSMODUAVBNLILYUIBBIXJCXXNQPCERRSMJTPQLMOXSKTRPWOFUSWXOYRJLBIJGIOYTEAEJEGGYAGSXNHNQTETANPWEGATHSBFLHCVHVIJUAKDVGQCWUSIFFFVAJYPJAFUYDXSLGPGESOUAYXBQIIOXWTXNOXLNCGWSUKVIBMOUGNHORYLSNVNNJLKKFDUAEISOLBLCXYHMDGVBVVVIKDLTMTDVWWJBXWXROVTJBXXKXLEWTTISKIUMYSACVUGGNANMCGUMFNQUXDLTHJNYTFIQEPKQQQSSROYJOILJYQXICXACWGOHCSHENXJILOMIIFCIOUDXDCINIVKIRJCVHWXSFQXMNRBJJWTPXNJADEOPEJBLKHKXNTORIRVRLXUXXAMKMODBXNLQCVJXVOTBRHXBBVJHPFEQFCRXYRRXHXPTXXSUESUTHUGOWQYQPQFPXQPVGEIRPQNKXXMBHIPECRUWFEWJUTYIKSMJSRQIQAIAMXTGDXSJIABHIGKUPJBCHWMVYTMQNQYGDHCNMBSVTPXNFRELFXXQYIOLCDEXDXDVSINICOXRMNSPICPQMOBIDJCNBJKXFAVMUXOXHERJIBIXLMXXULDXKXXHAQDXEXIWXOEEUGKSUGCMRWJDPYCYKXTPCOXMURAJCPRXKFJAJALERWRHVMFHOGMFHXGSXQDPJCJNXRQFGHKRCYTEBJDHPCMYFEAPWSVVMMBVUJJMCAAYURHUPVQVJYDCSNMQEMNIFEXYXIIXBVRVILXAUCBDXRJHGPKPYXHPPPNVSBBCDRLVVIYPKAKYIXTJVYDGVPHXULWMADBEICNIFKWUOOHEFNANDKOXMCVBVORLQYNXLULOEGVGWNKNMOHYVRSYSOVYGAKCGAWKGAIAQNQR",
+        recipeConfig: [
+            { "op": "SIGABA",
+                "args": [
+                    "YCHLQSUGBDIXNZKERPVJTAWFOM", true, "A",
+                    "INPXBWETGUYSAOCHVLDMQKZJFR", false, "B",
+                    "WNDRIOZPTAXHFJYQBMSVEKUCGL", false, "C",
+                    "TZGHOBKRVUXLQDMPNFWCJYEIAS", false, "D",
+                    "YWTAHRQJVLCEXUNGBIPZMSDFOK", true, "E",
+                    "QSLRBTEKOGAICFWYVMHJNXZUDP", false, "F",
+                    "CHJDQIGNBSAKVTUOXFWLEPRMZY", false, "G",
+                    "CDFAJXTIMNBEQHSUGRYLWZKVPO", true, "H",
+                    "XHFESZDNRBCGKQIJLTVMUOYAPW", false, "I",
+                    "EZJQXMOGYTCSFRIUPVNADLHWBK", false, "J",
+                    "7591482630", "0",
+                    "3810592764", "1",
+                    "4086153297", "2",
+                    "3980526174", "3",
+                    "6497135280", "4",
+                    "Decrypt"]
+            }
+        ]
+    }
+]);