cyberchef 9.40.0 → 9.43.0

package/CHANGELOG.md

@@ -13,6 +13,15 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.42.0] - 2022-07-08
+- Added 'LS47 Encrypt' and 'LS47 Decrypt' operations [@n1073645] | [#951]
+
+### [9.41.0] - 2022-07-08
+- Added 'Caesar Box Cipher' operation [@n1073645] | [#1066]
+
+### [9.40.0] - 2022-07-08
+- Added 'P-list Viewer' operation [@n1073645] | [#906]
+
 ### [9.39.0] - 2022-06-09
 - Added 'ELF Info' operation [@n1073645] | [#1364]
 
@@ -294,6 +303,9 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.42.0]: https://github.com/gchq/CyberChef/releases/tag/v9.42.0
+[9.41.0]: https://github.com/gchq/CyberChef/releases/tag/v9.41.0
+[9.40.0]: https://github.com/gchq/CyberChef/releases/tag/v9.40.0
 [9.39.0]: https://github.com/gchq/CyberChef/releases/tag/v9.39.0
 [9.38.0]: https://github.com/gchq/CyberChef/releases/tag/v9.38.0
 [9.37.0]: https://github.com/gchq/CyberChef/releases/tag/v9.37.0
@@ -491,10 +503,12 @@ All major and minor version changes will be documented in this file. Details of
 [#674]: https://github.com/gchq/CyberChef/pull/674
 [#683]: https://github.com/gchq/CyberChef/pull/683
 [#865]: https://github.com/gchq/CyberChef/pull/865
+[#906]: https://github.com/gchq/CyberChef/pull/906
 [#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
+[#951]: https://github.com/gchq/CyberChef/pull/951
 [#952]: https://github.com/gchq/CyberChef/pull/952
 [#965]: https://github.com/gchq/CyberChef/pull/965
 [#966]: https://github.com/gchq/CyberChef/pull/966
@@ -506,6 +520,7 @@ All major and minor version changes will be documented in this file. Details of
 [#1045]: https://github.com/gchq/CyberChef/pull/1045
 [#1049]: https://github.com/gchq/CyberChef/pull/1049
 [#1065]: https://github.com/gchq/CyberChef/pull/1065
+[#1066]: https://github.com/gchq/CyberChef/pull/1066
 [#1083]: https://github.com/gchq/CyberChef/pull/1083
 [#1189]: https://github.com/gchq/CyberChef/pull/1189
 [#1242]: https://github.com/gchq/CyberChef/pull/1242

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.40.0",
+  "version": "9.43.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",

package/src/core/config/Categories.json

@@ -79,6 +79,8 @@
             "DES Decrypt",
             "Triple DES Encrypt",
             "Triple DES Decrypt",
+            "LS47 Encrypt",
+            "LS47 Decrypt",
             "RC2 Encrypt",
             "RC2 Decrypt",
             "RC4",
@@ -86,7 +88,9 @@
             "SM4 Encrypt",
             "SM4 Decrypt",
             "ROT13",
+            "ROT13 Brute Force",
             "ROT47",
+            "ROT47 Brute Force",
             "XOR",
             "XOR Brute Force",
             "Vigenère Encode",
@@ -97,6 +101,7 @@
             "Bacon Cipher Decode",
             "Bifid Cipher Encode",
             "Bifid Cipher Decode",
+            "Caesar Box Cipher",
             "Affine Cipher Encode",
             "Affine Cipher Decode",
             "A1Z26 Cipher Encode",

package/src/core/config/OperationConfig.json

@@ -1469,6 +1469,22 @@
         "manualBake": false,
         "args": []
     },
+    "Caesar Box Cipher": {
+        "module": "Ciphers",
+        "description": "Caesar Box is a transposition cipher used in the Roman Empire, in which letters of the message are written in rows in a square (or a rectangle) and then, read by column.",
+        "infoURL": "https://www.dcode.fr/caesar-box-cipher",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Box Height",
+                "type": "number",
+                "value": 1
+            }
+        ]
+    },
     "Cartesian Product": {
         "module": "Default",
         "description": "Calculates the cartesian product of multiple sets of data, returning all possible combinations.",
@@ -7918,6 +7934,53 @@
             }
         ]
     },
+    "LS47 Decrypt": {
+        "module": "Crypto",
+        "description": "This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.<br>The LS47 alphabet consists of following characters: <code>_abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()</code><br>An LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.",
+        "infoURL": "https://github.com/exaexa/ls47",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Password",
+                "type": "string",
+                "value": ""
+            },
+            {
+                "name": "Padding",
+                "type": "number",
+                "value": 10
+            }
+        ]
+    },
+    "LS47 Encrypt": {
+        "module": "Crypto",
+        "description": "This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.<br>The LS47 alphabet consists of following characters: <code>_abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()</code><br>A LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.",
+        "infoURL": "https://github.com/exaexa/ls47",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Password",
+                "type": "string",
+                "value": ""
+            },
+            {
+                "name": "Padding",
+                "type": "number",
+                "value": 10
+            },
+            {
+                "name": "Signature",
+                "type": "string",
+                "value": ""
+            }
+        ]
+    },
     "Label": {
         "module": "Default",
         "description": "Provides a location for conditional and fixed jumps to redirect execution to.",
@@ -10115,6 +10178,52 @@
             }
         ]
     },
+    "ROT13 Brute Force": {
+        "module": "Default",
+        "description": "Try all meaningful amounts for ROT13.<br><br>Optionally you can enter your known plaintext (crib) to filter the result.",
+        "infoURL": "https://wikipedia.org/wiki/ROT13",
+        "inputType": "byteArray",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Rotate lower case chars",
+                "type": "boolean",
+                "value": true
+            },
+            {
+                "name": "Rotate upper case chars",
+                "type": "boolean",
+                "value": true
+            },
+            {
+                "name": "Rotate numbers",
+                "type": "boolean",
+                "value": false
+            },
+            {
+                "name": "Sample length",
+                "type": "number",
+                "value": 100
+            },
+            {
+                "name": "Sample offset",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Print amount",
+                "type": "boolean",
+                "value": true
+            },
+            {
+                "name": "Crib (known plaintext string)",
+                "type": "string",
+                "value": ""
+            }
+        ]
+    },
     "ROT47": {
         "module": "Default",
         "description": "A slightly more complex variation of a caesar cipher, which includes ASCII characters from 33 '!' to 126 '~'. Default rotation: 47.",
@@ -10131,6 +10240,37 @@
             }
         ]
     },
+    "ROT47 Brute Force": {
+        "module": "Default",
+        "description": "Try all meaningful amounts for ROT47.<br><br>Optionally you can enter your known plaintext (crib) to filter the result.",
+        "infoURL": "https://wikipedia.org/wiki/ROT13#Variants",
+        "inputType": "byteArray",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Sample length",
+                "type": "number",
+                "value": 100
+            },
+            {
+                "name": "Sample offset",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Print amount",
+                "type": "boolean",
+                "value": true
+            },
+            {
+                "name": "Crib (known plaintext string)",
+                "type": "string",
+                "value": ""
+            }
+        ]
+    },
     "RSA Decrypt": {
         "module": "Ciphers",
         "description": "Decrypt an RSA encrypted message with a PEM encoded private key.",

package/src/core/config/modules/Ciphers.mjs

@@ -16,6 +16,7 @@ import BifidCipherDecode from "../../operations/BifidCipherDecode.mjs";
 import BifidCipherEncode from "../../operations/BifidCipherEncode.mjs";
 import BlowfishDecrypt from "../../operations/BlowfishDecrypt.mjs";
 import BlowfishEncrypt from "../../operations/BlowfishEncrypt.mjs";
+import CaesarBoxCipher from "../../operations/CaesarBoxCipher.mjs";
 import DESDecrypt from "../../operations/DESDecrypt.mjs";
 import DESEncrypt from "../../operations/DESEncrypt.mjs";
 import DeriveEVPKey from "../../operations/DeriveEVPKey.mjs";
@@ -53,6 +54,7 @@ OpModules.Ciphers = {
     "Bifid Cipher Encode": BifidCipherEncode,
     "Blowfish Decrypt": BlowfishDecrypt,
     "Blowfish Encrypt": BlowfishEncrypt,
+    "Caesar Box Cipher": CaesarBoxCipher,
     "DES Decrypt": DESDecrypt,
     "DES Encrypt": DESEncrypt,
     "Derive EVP key": DeriveEVPKey,

package/src/core/config/modules/Crypto.mjs

@@ -34,6 +34,8 @@ import JWTDecode from "../../operations/JWTDecode.mjs";
 import JWTSign from "../../operations/JWTSign.mjs";
 import JWTVerify from "../../operations/JWTVerify.mjs";
 import Keccak from "../../operations/Keccak.mjs";
+import LS47Decrypt from "../../operations/LS47Decrypt.mjs";
+import LS47Encrypt from "../../operations/LS47Encrypt.mjs";
 import MD2 from "../../operations/MD2.mjs";
 import MD4 from "../../operations/MD4.mjs";
 import MD5 from "../../operations/MD5.mjs";
@@ -83,6 +85,8 @@ OpModules.Crypto = {
     "JWT Sign": JWTSign,
     "JWT Verify": JWTVerify,
     "Keccak": Keccak,
+    "LS47 Decrypt": LS47Decrypt,
+    "LS47 Encrypt": LS47Encrypt,
     "MD2": MD2,
     "MD4": MD4,
     "MD5": MD5,

package/src/core/config/modules/Default.mjs

@@ -107,7 +107,9 @@ import ParseUNIXFilePermissions from "../../operations/ParseUNIXFilePermissions.
 import PlayMedia from "../../operations/PlayMedia.mjs";
 import PowerSet from "../../operations/PowerSet.mjs";
 import ROT13 from "../../operations/ROT13.mjs";
+import ROT13BruteForce from "../../operations/ROT13BruteForce.mjs";
 import ROT47 from "../../operations/ROT47.mjs";
+import ROT47BruteForce from "../../operations/ROT47BruteForce.mjs";
 import RemoveDiacritics from "../../operations/RemoveDiacritics.mjs";
 import RemoveLineNumbers from "../../operations/RemoveLineNumbers.mjs";
 import RemoveNullBytes from "../../operations/RemoveNullBytes.mjs";
@@ -277,7 +279,9 @@ OpModules.Default = {
     "Play Media": PlayMedia,
     "Power Set": PowerSet,
     "ROT13": ROT13,
+    "ROT13 Brute Force": ROT13BruteForce,
     "ROT47": ROT47,
+    "ROT47 Brute Force": ROT47BruteForce,
     "Remove Diacritics": RemoveDiacritics,
     "Remove line numbers": RemoveLineNumbers,
     "Remove null bytes": RemoveNullBytes,

package/src/core/lib/LS47.mjs

@@ -0,0 +1,244 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import OperationError from "../errors/OperationError.mjs";
+
+const letters = "_abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()";
+const tiles = [];
+
+/**
+ * Initialises the tiles with values and positions.
+ */
+export function initTiles() {
+    for (let i = 0; i < 49; i++)
+        tiles.push([letters.charAt(i), [Math.floor(i/7), i % 7]]);
+}
+
+/**
+ * Rotates the key "down".
+ *
+ * @param {string} key
+ * @param {number} col
+ * @param {number} n
+ * @returns {string}
+ */
+function rotateDown(key, col, n) {
+    const lines = [];
+    for (let i = 0; i < 7; i++)
+        lines.push(key.slice(i*7, (i + 1) * 7));
+    const lefts = [];
+    let mids = [];
+    const rights = [];
+    lines.forEach((element) => {
+        lefts.push(element.slice(0, col));
+        mids.push(element.charAt(col));
+        rights.push(element.slice(col+1));
+    });
+    n = (7 - n % 7) % 7;
+    mids = mids.slice(n).concat(mids.slice(0, n));
+    let result = "";
+    for (let i = 0; i < 7; i++)
+        result += lefts[i] + mids[i] + rights[i];
+    return result;
+}
+
+/**
+ * Rotates the key "right".
+ *
+ * @param {string} key
+ * @param {number} row
+ * @param {number} n
+ * @returns {string}
+ */
+function rotateRight(key, row, n) {
+    const mid = key.slice(row * 7, (row + 1) * 7);
+    n = (7 - n % 7) % 7;
+    return key.slice(0, 7 * row) + mid.slice(n) + mid.slice(0, n) + key.slice(7 * (row + 1));
+}
+
+/**
+ * Finds the position of a letter in the tiles.
+ *
+ * @param {string} letter
+ * @returns {string}
+ */
+function findIx(letter) {
+    for (let i = 0; i < tiles.length; i++)
+        if (tiles[i][0] === letter)
+            return tiles[i][1];
+    throw new OperationError("Letter " + letter + " is not included in LS47");
+}
+
+/**
+ * Derives key from the input password.
+ *
+ * @param {string} password
+ * @returns {string}
+ */
+export function deriveKey(password) {
+    let i = 0;
+    let k = letters;
+    for (const c of password) {
+        const [row, col] = findIx(c);
+        k = rotateDown(rotateRight(k, i, col), i, row);
+        i = (i + 1) % 7;
+    }
+    return k;
+}
+
+/**
+ * Checks the key is a valid key.
+ *
+ * @param {string} key
+ */
+function checkKey(key) {
+    if (key.length !== letters.length)
+        throw new OperationError("Wrong key size");
+    const counts = new Array();
+    for (let i = 0; i < letters.length; i++)
+        counts[letters.charAt(i)] = 0;
+    for (const elem of letters) {
+        if (letters.indexOf(elem) === -1)
+            throw new OperationError("Letter " + elem + " not in LS47");
+        counts[elem]++;
+        if (counts[elem] > 1)
+            throw new OperationError("Letter duplicated in the key");
+    }
+}
+
+/**
+ * Finds the position of a letter in they key.
+ *
+ * @param {letter} key
+ * @param {string} letter
+ * @returns {object}
+ */
+function findPos (key, letter) {
+    const index = key.indexOf(letter);
+    if (index >= 0 && index < 49)
+        return [Math.floor(index/7), index%7];
+    throw new OperationError("Letter " + letter + " is not in the key");
+}
+
+/**
+ * Returns the character at the position on the tiles.
+ *
+ * @param {string} key
+ * @param {object} coord
+ * @returns {string}
+ */
+function findAtPos(key, coord) {
+    return key.charAt(coord[1] + (coord[0] * 7));
+}
+
+/**
+ * Returns new position by adding two positions.
+ *
+ * @param {object} a
+ * @param {object} b
+ * @returns {object}
+ */
+function addPos(a, b) {
+    return [(a[0] + b[0]) % 7, (a[1] + b[1]) % 7];
+}
+
+/**
+ * Returns new position by subtracting two positions.
+ * Note: We have to manually do the remainder division, since JS does not
+ * operate correctly on negative numbers (e.g. -3 % 4 = -3 when it should be 1).
+ *
+ * @param {object} a
+ * @param {object} b
+ * @returns {object}
+ */
+function subPos(a, b) {
+    const asub = a[0] - b[0];
+    const bsub = a[1] - b[1];
+    return [asub - (Math.floor(asub/7) * 7), bsub - (Math.floor(bsub/7) * 7)];
+}
+
+/**
+ * Encrypts the plaintext string.
+ *
+ * @param {string} key
+ * @param {string} plaintext
+ * @returns {string}
+ */
+function encrypt(key, plaintext) {
+    checkKey(key);
+    let mp = [0, 0];
+    let ciphertext = "";
+    for (const p of plaintext) {
+        const pp = findPos(key, p);
+        const mix = findIx(findAtPos(key, mp));
+        let cp = addPos(pp, mix);
+        const c = findAtPos(key, cp);
+        ciphertext += c;
+        key = rotateRight(key, pp[0], 1);
+        cp = findPos(key, c);
+        key = rotateDown(key, cp[1], 1);
+        mp = addPos(mp, findIx(c));
+    }
+    return ciphertext;
+}
+
+/**
+ * Decrypts the ciphertext string.
+ *
+ * @param {string} key
+ * @param {string} ciphertext
+ * @returns {string}
+ */
+function decrypt(key, ciphertext) {
+    checkKey(key);
+    let mp = [0, 0];
+    let plaintext = "";
+    for (const c of ciphertext) {
+        let cp = findPos(key, c);
+        const mix = findIx(findAtPos(key, mp));
+        const pp = subPos(cp, mix);
+        const p = findAtPos(key, pp);
+        plaintext += p;
+        key = rotateRight(key, pp[0], 1);
+        cp = findPos(key, c);
+        key = rotateDown(key, cp[1], 1);
+        mp = addPos(mp, findIx(c));
+    }
+    return plaintext;
+}
+
+/**
+ * Adds padding to the input.
+ *
+ * @param {string} key
+ * @param {string} plaintext
+ * @param {string} signature
+ * @param {number} paddingSize
+ * @returns {string}
+ */
+export function encryptPad(key, plaintext, signature, paddingSize) {
+    initTiles();
+    checkKey(key);
+    let padding = "";
+    for (let i = 0; i < paddingSize; i++) {
+        padding += letters.charAt(Math.floor(Math.random() * letters.length));
+    }
+    return encrypt(key, padding+plaintext+"---"+signature);
+}
+
+/**
+ * Removes padding from the ouput.
+ *
+ * @param {string} key
+ * @param {string} ciphertext
+ * @param {number} paddingSize
+ * @returns {string}
+ */
+export function decryptPad(key, ciphertext, paddingSize) {
+    initTiles();
+    checkKey(key);
+    return decrypt(key, ciphertext).slice(paddingSize);
+}

package/src/core/operations/CaesarBoxCipher.mjs

@@ -0,0 +1,61 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Caesar Box Cipher operation
+ */
+class CaesarBoxCipher extends Operation {
+
+    /**
+     * CaesarBoxCipher constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Caesar Box Cipher";
+        this.module = "Ciphers";
+        this.description = "Caesar Box is a transposition cipher used in the Roman Empire, in which letters of the message are written in rows in a square (or a rectangle) and then, read by column.";
+        this.infoURL = "https://www.dcode.fr/caesar-box-cipher";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Box Height",
+                type: "number",
+                value: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const tableHeight = args[0];
+        const tableWidth = Math.ceil(input.length / tableHeight);
+        while (input.indexOf(" ") !== -1)
+            input = input.replace(" ", "");
+        for (let i = 0; i < (tableHeight * tableWidth) - input.length; i++) {
+            input += "\x00";
+        }
+        let result = "";
+        for (let i = 0; i < tableHeight; i++) {
+            for (let j = i; j < input.length; j += tableHeight) {
+                if (input.charAt(j) !== "\x00") {
+                    result += input.charAt(j);
+                }
+            }
+        }
+        return result;
+    }
+
+}
+
+export default CaesarBoxCipher;

package/src/core/operations/LS47Decrypt.mjs

@@ -0,0 +1,57 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import * as LS47 from "../lib/LS47.mjs";
+
+/**
+ * LS47 Decrypt operation
+ */
+class LS47Decrypt extends Operation {
+
+    /**
+     * LS47Decrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "LS47 Decrypt";
+        this.module = "Crypto";
+        this.description = "This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.<br>The LS47 alphabet consists of following characters: <code>_abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()</code><br>An LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.";
+        this.infoURL = "https://github.com/exaexa/ls47";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Password",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Padding",
+                type: "number",
+                value: 10
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        this.paddingSize = parseInt(args[1], 10);
+
+        LS47.initTiles();
+
+        const key = LS47.deriveKey(args[0]);
+        return LS47.decryptPad(key, input, this.paddingSize);
+    }
+
+}
+
+export default LS47Decrypt;

package/src/core/operations/LS47Encrypt.mjs

@@ -0,0 +1,62 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import * as LS47 from "../lib/LS47.mjs";
+
+/**
+ * LS47 Encrypt operation
+ */
+class LS47Encrypt extends Operation {
+
+    /**
+     * LS47Encrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "LS47 Encrypt";
+        this.module = "Crypto";
+        this.description = "This is a slight improvement of the ElsieFour cipher as described by Alan Kaminsky. We use 7x7 characters instead of original (barely fitting) 6x6, to be able to encrypt some structured information. We also describe a simple key-expansion algorithm, because remembering passwords is popular. Similar security considerations as with ElsieFour hold.<br>The LS47 alphabet consists of following characters: <code>_abcdefghijklmnopqrstuvwxyz.0123456789,-+*/:?!'()</code><br>A LS47 key is a permutation of the alphabet that is then represented in a 7x7 grid used for the encryption or decryption.";
+        this.infoURL = "https://github.com/exaexa/ls47";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Password",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Padding",
+                type: "number",
+                value: 10
+            },
+            {
+                name: "Signature",
+                type: "string",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        this.paddingSize = parseInt(args[1], 10);
+
+        LS47.initTiles();
+
+        const key = LS47.deriveKey(args[0]);
+        return LS47.encryptPad(key, input, args[2], this.paddingSize);
+    }
+
+}
+
+export default LS47Encrypt;

package/src/core/operations/ROT13BruteForce.mjs

@@ -0,0 +1,102 @@
+/**
+ * @author MikeCAT
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * ROT13 Brute Force operation.
+ */
+class ROT13BruteForce extends Operation {
+
+    /**
+     * ROT13BruteForce constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "ROT13 Brute Force";
+        this.module = "Default";
+        this.description = "Try all meaningful amounts for ROT13.<br><br>Optionally you can enter your known plaintext (crib) to filter the result.";
+        this.infoURL = "https://wikipedia.org/wiki/ROT13";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Rotate lower case chars",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Rotate upper case chars",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Rotate numbers",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Sample length",
+                type: "number",
+                value: 100
+            },
+            {
+                name: "Sample offset",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Print amount",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Crib (known plaintext string)",
+                type: "string",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [rotateLower, rotateUpper, rotateNum, sampleLength, sampleOffset, printAmount, crib] = args;
+        const sample = input.slice(sampleOffset, sampleOffset + sampleLength);
+        const cribLower = crib.toLowerCase();
+        const lowerStart = "a".charCodeAt(0), upperStart = "A".charCodeAt(0), numStart = "0".charCodeAt(0);
+        const result = [];
+        for (let amount = 1; amount < 26; amount++) {
+            const rotated = sample.slice();
+            for (let i = 0; i < rotated.length; i++) {
+                if (rotateLower && lowerStart <= rotated[i] && rotated[i] < lowerStart + 26) {
+                    rotated[i] = (rotated[i] - lowerStart + amount) % 26 + lowerStart;
+                } else if (rotateUpper && upperStart <= rotated[i] && rotated[i] < upperStart + 26) {
+                    rotated[i] = (rotated[i] - upperStart + amount) % 26 + upperStart;
+                } else if (rotateNum && numStart <= rotated[i] && rotated[i] < numStart + 10) {
+                    rotated[i] = (rotated[i] - numStart + amount) % 10 + numStart;
+                }
+            }
+            const rotatedString = Utils.byteArrayToUtf8(rotated);
+            if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) {
+                const rotatedStringPrintable = Utils.printable(rotatedString, false);
+                if (printAmount) {
+                    const amountStr = "Amount = " + (" " + amount).slice(-2) + ": ";
+                    result.push(amountStr + rotatedStringPrintable);
+                } else {
+                    result.push(rotatedStringPrintable);
+                }
+            }
+        }
+        return result.join("\n");
+    }
+}
+
+export default ROT13BruteForce;

package/src/core/operations/ROT47BruteForce.mjs

@@ -0,0 +1,82 @@
+/**
+ * @author MikeCAT
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * ROT47 Brute Force operation.
+ */
+class ROT47BruteForce extends Operation {
+
+    /**
+     * ROT47BruteForce constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "ROT47 Brute Force";
+        this.module = "Default";
+        this.description = "Try all meaningful amounts for ROT47.<br><br>Optionally you can enter your known plaintext (crib) to filter the result.";
+        this.infoURL = "https://wikipedia.org/wiki/ROT13#Variants";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Sample length",
+                type: "number",
+                value: 100
+            },
+            {
+                name: "Sample offset",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Print amount",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Crib (known plaintext string)",
+                type: "string",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [sampleLength, sampleOffset, printAmount, crib] = args;
+        const sample = input.slice(sampleOffset, sampleOffset + sampleLength);
+        const cribLower = crib.toLowerCase();
+        const result = [];
+        for (let amount = 1; amount < 94; amount++) {
+            const rotated = sample.slice();
+            for (let i = 0; i < rotated.length; i++) {
+                if (33 <= rotated[i] && rotated[i] <= 126) {
+                    rotated[i] = (rotated[i] - 33 + amount) % 94 + 33;
+                }
+            }
+            const rotatedString = Utils.byteArrayToUtf8(rotated);
+            if (rotatedString.toLowerCase().indexOf(cribLower) >= 0) {
+                const rotatedStringPrintable = Utils.printable(rotatedString, false);
+                if (printAmount) {
+                    const amountStr = "Amount = " + (" " + amount).slice(-2) + ": ";
+                    result.push(amountStr + rotatedStringPrintable);
+                } else {
+                    result.push(rotatedStringPrintable);
+                }
+            }
+        }
+        return result.join("\n");
+    }
+}
+
+export default ROT47BruteForce;

package/src/core/operations/index.mjs

@@ -48,6 +48,7 @@ import CSSMinify from "./CSSMinify.mjs";
 import CSSSelector from "./CSSSelector.mjs";
 import CSVToJSON from "./CSVToJSON.mjs";
 import CTPH from "./CTPH.mjs";
+import CaesarBoxCipher from "./CaesarBoxCipher.mjs";
 import CartesianProduct from "./CartesianProduct.mjs";
 import ChangeIPFormat from "./ChangeIPFormat.mjs";
 import ChiSquare from "./ChiSquare.mjs";
@@ -191,6 +192,8 @@ import JavaScriptMinify from "./JavaScriptMinify.mjs";
 import JavaScriptParser from "./JavaScriptParser.mjs";
 import Jump from "./Jump.mjs";
 import Keccak from "./Keccak.mjs";
+import LS47Decrypt from "./LS47Decrypt.mjs";
+import LS47Encrypt from "./LS47Encrypt.mjs";
 import Label from "./Label.mjs";
 import Lorenz from "./Lorenz.mjs";
 import LuhnChecksum from "./LuhnChecksum.mjs";
@@ -249,7 +252,9 @@ import RC4 from "./RC4.mjs";
 import RC4Drop from "./RC4Drop.mjs";
 import RIPEMD from "./RIPEMD.mjs";
 import ROT13 from "./ROT13.mjs";
+import ROT13BruteForce from "./ROT13BruteForce.mjs";
 import ROT47 from "./ROT47.mjs";
+import ROT47BruteForce from "./ROT47BruteForce.mjs";
 import RSADecrypt from "./RSADecrypt.mjs";
 import RSAEncrypt from "./RSAEncrypt.mjs";
 import RSASign from "./RSASign.mjs";
@@ -423,6 +428,7 @@ export {
     CSSSelector,
     CSVToJSON,
     CTPH,
+    CaesarBoxCipher,
     CartesianProduct,
     ChangeIPFormat,
     ChiSquare,
@@ -566,6 +572,8 @@ export {
     JavaScriptParser,
     Jump,
     Keccak,
+    LS47Decrypt,
+    LS47Encrypt,
     Label,
     Lorenz,
     LuhnChecksum,
@@ -624,7 +632,9 @@ export {
     RC4Drop,
     RIPEMD,
     ROT13,
+    ROT13BruteForce,
     ROT47,
+    ROT47BruteForce,
     RSADecrypt,
     RSAEncrypt,
     RSASign,

package/src/node/index.mjs

@@ -58,6 +58,7 @@ import {
     CSSSelector as core_CSSSelector,
     CSVToJSON as core_CSVToJSON,
     CTPH as core_CTPH,
+    CaesarBoxCipher as core_CaesarBoxCipher,
     CartesianProduct as core_CartesianProduct,
     ChangeIPFormat as core_ChangeIPFormat,
     ChiSquare as core_ChiSquare,
@@ -194,6 +195,8 @@ import {
     JWTSign as core_JWTSign,
     JWTVerify as core_JWTVerify,
     Keccak as core_Keccak,
+    LS47Decrypt as core_LS47Decrypt,
+    LS47Encrypt as core_LS47Encrypt,
     Lorenz as core_Lorenz,
     LuhnChecksum as core_LuhnChecksum,
     MD2 as core_MD2,
@@ -250,7 +253,9 @@ import {
     RC4Drop as core_RC4Drop,
     RIPEMD as core_RIPEMD,
     ROT13 as core_ROT13,
+    ROT13BruteForce as core_ROT13BruteForce,
     ROT47 as core_ROT47,
+    ROT47BruteForce as core_ROT47BruteForce,
     RSADecrypt as core_RSADecrypt,
     RSAEncrypt as core_RSAEncrypt,
     RSASign as core_RSASign,
@@ -433,6 +438,7 @@ function generateChef() {
         "CSSSelector": _wrap(core_CSSSelector),
         "CSVToJSON": _wrap(core_CSVToJSON),
         "CTPH": _wrap(core_CTPH),
+        "caesarBoxCipher": _wrap(core_CaesarBoxCipher),
         "cartesianProduct": _wrap(core_CartesianProduct),
         "changeIPFormat": _wrap(core_ChangeIPFormat),
         "chiSquare": _wrap(core_ChiSquare),
@@ -569,6 +575,8 @@ function generateChef() {
         "JWTSign": _wrap(core_JWTSign),
         "JWTVerify": _wrap(core_JWTVerify),
         "keccak": _wrap(core_Keccak),
+        "LS47Decrypt": _wrap(core_LS47Decrypt),
+        "LS47Encrypt": _wrap(core_LS47Encrypt),
         "lorenz": _wrap(core_Lorenz),
         "luhnChecksum": _wrap(core_LuhnChecksum),
         "MD2": _wrap(core_MD2),
@@ -625,7 +633,9 @@ function generateChef() {
         "RC4Drop": _wrap(core_RC4Drop),
         "RIPEMD": _wrap(core_RIPEMD),
         "ROT13": _wrap(core_ROT13),
+        "ROT13BruteForce": _wrap(core_ROT13BruteForce),
         "ROT47": _wrap(core_ROT47),
+        "ROT47BruteForce": _wrap(core_ROT47BruteForce),
         "RSADecrypt": _wrap(core_RSADecrypt),
         "RSAEncrypt": _wrap(core_RSAEncrypt),
         "RSASign": _wrap(core_RSASign),
@@ -816,6 +826,7 @@ const CSSMinify = chef.CSSMinify;
 const CSSSelector = chef.CSSSelector;
 const CSVToJSON = chef.CSVToJSON;
 const CTPH = chef.CTPH;
+const caesarBoxCipher = chef.caesarBoxCipher;
 const cartesianProduct = chef.cartesianProduct;
 const changeIPFormat = chef.changeIPFormat;
 const chiSquare = chef.chiSquare;
@@ -959,6 +970,8 @@ const javaScriptMinify = chef.javaScriptMinify;
 const javaScriptParser = chef.javaScriptParser;
 const jump = chef.jump;
 const keccak = chef.keccak;
+const LS47Decrypt = chef.LS47Decrypt;
+const LS47Encrypt = chef.LS47Encrypt;
 const label = chef.label;
 const lorenz = chef.lorenz;
 const luhnChecksum = chef.luhnChecksum;
@@ -1017,7 +1030,9 @@ const RC4 = chef.RC4;
 const RC4Drop = chef.RC4Drop;
 const RIPEMD = chef.RIPEMD;
 const ROT13 = chef.ROT13;
+const ROT13BruteForce = chef.ROT13BruteForce;
 const ROT47 = chef.ROT47;
+const ROT47BruteForce = chef.ROT47BruteForce;
 const RSADecrypt = chef.RSADecrypt;
 const RSAEncrypt = chef.RSAEncrypt;
 const RSASign = chef.RSASign;
@@ -1193,6 +1208,7 @@ const operations = [
     CSSSelector,
     CSVToJSON,
     CTPH,
+    caesarBoxCipher,
     cartesianProduct,
     changeIPFormat,
     chiSquare,
@@ -1336,6 +1352,8 @@ const operations = [
     javaScriptParser,
     jump,
     keccak,
+    LS47Decrypt,
+    LS47Encrypt,
     label,
     lorenz,
     luhnChecksum,
@@ -1394,7 +1412,9 @@ const operations = [
     RC4Drop,
     RIPEMD,
     ROT13,
+    ROT13BruteForce,
     ROT47,
+    ROT47BruteForce,
     RSADecrypt,
     RSAEncrypt,
     RSASign,
@@ -1574,6 +1594,7 @@ export {
     CSSSelector,
     CSVToJSON,
     CTPH,
+    caesarBoxCipher,
     cartesianProduct,
     changeIPFormat,
     chiSquare,
@@ -1717,6 +1738,8 @@ export {
     javaScriptParser,
     jump,
     keccak,
+    LS47Decrypt,
+    LS47Encrypt,
     label,
     lorenz,
     luhnChecksum,
@@ -1775,7 +1798,9 @@ export {
     RC4Drop,
     RIPEMD,
     ROT13,
+    ROT13BruteForce,
     ROT47,
+    ROT47BruteForce,
     RSADecrypt,
     RSAEncrypt,
     RSASign,

package/tests/operations/index.mjs

@@ -116,6 +116,8 @@ import "./tests/GetAllCasings.mjs";
 import "./tests/SIGABA.mjs";
 import "./tests/ELFInfo.mjs";
 import "./tests/Subsection.mjs";
+import "./tests/CaesarBoxCipher.mjs";
+import "./tests/LS47.mjs";
 
 
 // Cannot test operations that use the File type yet

package/tests/operations/tests/CaesarBoxCipher.mjs

@@ -0,0 +1,45 @@
+/**
+ * Caesar Box Cipher tests.
+ *
+ * @author n1073645 [n1073645@gmail.com]
+ *
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "Caesar Box Cipher: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "Caesar Box Cipher",
+                args: ["1"],
+            },
+        ],
+    },
+    {
+        name: "Caesar Box Cipher: Hello World!",
+        input: "Hello World!",
+        expectedOutput: "Hlodeor!lWl",
+        recipeConfig: [
+            {
+                op: "Caesar Box Cipher",
+                args: ["3"],
+            },
+        ],
+    },
+    {
+        name: "Caesar Box Cipher: Hello World!",
+        input: "Hlodeor!lWl",
+        expectedOutput: "HelloWorld!",
+        recipeConfig: [
+            {
+                op: "Caesar Box Cipher",
+                args: ["4"],
+            },
+        ],
+    }
+]);

package/tests/operations/tests/LS47.mjs

@@ -0,0 +1,45 @@
+/**
+ * LS47 tests.
+ *
+ * @author n1073645 [n1073645@gmail.com]
+ *
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "LS47 Encrypt",
+        input: "thequickbrownfoxjumped",
+        expectedOutput: "(,t74ci78cp/8trx*yesu:alp1wqy",
+        recipeConfig: [
+            {
+                op: "LS47 Encrypt",
+                args: ["helloworld", 0, "test"],
+            },
+        ],
+    },
+    {
+        name: "LS47 Decrypt",
+        input: "(,t74ci78cp/8trx*yesu:alp1wqy",
+        expectedOutput: "thequickbrownfoxjumped---test",
+        recipeConfig: [
+            {
+                op: "LS47 Decrypt",
+                args: ["helloworld", 0],
+            },
+        ],
+    },
+    {
+        name: "LS47 Encrypt",
+        input: "thequickbrownfoxjumped",
+        expectedOutput: "Letter H is not included in LS47",
+        recipeConfig: [
+            {
+                op: "LS47 Encrypt",
+                args: ["Helloworld", 0, "test"],
+            },
+        ],
+    }
+]);