cyberchef 9.43.0 → 9.46.0

package/CHANGELOG.md

@@ -13,6 +13,15 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.45.0] - 2022-07-08
+- Added 'ROT8000' operation [@thomasleplus] | [#1250]
+
+### [9.44.0] - 2022-07-08
+- Added 'LZString Compress' and 'LZString Decompress' operations [@crespyl] | [#1266]
+
+### [9.43.0] - 2022-07-08
+- Added 'ROT13 Brute Force' and 'ROT47 Brute Force' operations [@mikecat] | [#1264]
+
 ### [9.42.0] - 2022-07-08
 - Added 'LS47 Encrypt' and 'LS47 Decrypt' operations [@n1073645] | [#951]
 
@@ -303,6 +312,9 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.45.0]: https://github.com/gchq/CyberChef/releases/tag/v9.45.0
+[9.44.0]: https://github.com/gchq/CyberChef/releases/tag/v9.44.0
+[9.43.0]: https://github.com/gchq/CyberChef/releases/tag/v9.43.0
 [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
@@ -430,6 +442,9 @@ All major and minor version changes will be documented in this file. Details of
 [@t-8ch]: https://github.com/t-8ch
 [@hettysymes]: https://github.com/hettysymes
 [@swesven]: https://github.com/swesven
+[@mikecat]: https://github.com/mikecat
+[@crespyl]: https://github.com/crespyl
+[@thomasleplus]: https://github.com/thomasleplus
 
 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
 [9a33498]: https://github.com/gchq/CyberChef/commit/9a33498fed26a8df9c9f35f39a78a174bf50a513
@@ -528,3 +543,7 @@ All major and minor version changes will be documented in this file. Details of
 [#1313]: https://github.com/gchq/CyberChef/pull/1313
 [#1326]: https://github.com/gchq/CyberChef/pull/1326
 [#1364]: https://github.com/gchq/CyberChef/pull/1364
+[#1264]: https://github.com/gchq/CyberChef/pull/1264
+[#1266]: https://github.com/gchq/CyberChef/pull/1266
+[#1250]: https://github.com/gchq/CyberChef/pull/1250
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.43.0",
+  "version": "9.46.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",
@@ -133,6 +133,7 @@
     "lodash": "^4.17.21",
     "loglevel": "^1.8.0",
     "loglevel-message-prefix": "^3.0.0",
+    "lz-string": "^1.4.4",
     "markdown-it": "^13.0.1",
     "moment": "^2.29.3",
     "moment-timezone": "^0.5.34",

package/src/core/config/Categories.json

@@ -91,6 +91,7 @@
             "ROT13 Brute Force",
             "ROT47",
             "ROT47 Brute Force",
+            "ROT8000",
             "XOR",
             "XOR Brute Force",
             "Vigenère Encode",
@@ -111,6 +112,8 @@
             "Atbash Cipher",
             "CipherSaber2 Encrypt",
             "CipherSaber2 Decrypt",
+            "Cetacean Cipher Encode",
+            "Cetacean Cipher Decode",
             "Substitute",
             "Derive PBKDF2 key",
             "Derive EVP key",
@@ -181,7 +184,8 @@
             "Bit shift right",
             "Rotate left",
             "Rotate right",
-            "ROT13"
+            "ROT13",
+            "ROT8000"
         ]
     },
     {
@@ -325,7 +329,9 @@
             "Bzip2 Decompress",
             "Bzip2 Compress",
             "Tar",
-            "Untar"
+            "Untar",
+            "LZString Compress",
+            "LZString Decompress"
         ]
     },
     {

package/src/core/config/OperationConfig.json

@@ -1506,6 +1506,33 @@
             }
         ]
     },
+    "Cetacean Cipher Decode": {
+        "module": "Ciphers",
+        "description": "Decode Cetacean Cipher input. <br/><br/>e.g. <code>EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe</code> becomes <code>hi</code>",
+        "infoURL": "https://hitchhikers.fandom.com/wiki/Dolphins",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [],
+        "checks": [
+            {
+                "pattern": "^(?:[eE]{16,})(?: [eE]{16,})*$",
+                "flags": "",
+                "args": []
+            }
+        ]
+    },
+    "Cetacean Cipher Encode": {
+        "module": "Ciphers",
+        "description": "Converts any input into Cetacean Cipher. <br/><br/>e.g. <code>hi</code> becomes <code>EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe</code>",
+        "infoURL": "https://hitchhikers.fandom.com/wiki/Dolphins",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": []
+    },
     "Change IP format": {
         "module": "Default",
         "description": "Convert an IP address from one format to another, e.g. <code>172.20.23.54</code> to <code>ac141736</code>",
@@ -7981,6 +8008,46 @@
             }
         ]
     },
+    "LZString Compress": {
+        "module": "Compression",
+        "description": "Compress the input with lz-string.",
+        "infoURL": "https://pieroxy.net/blog/pages/lz-string/index.html",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Compression Format",
+                "type": "option",
+                "value": [
+                    "default",
+                    "UTF16",
+                    "Base64"
+                ]
+            }
+        ]
+    },
+    "LZString Decompress": {
+        "module": "Compression",
+        "description": "Decompresses data that was compressed with lz-string.",
+        "infoURL": "https://pieroxy.net/blog/pages/lz-string/index.html",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Compression Format",
+                "type": "option",
+                "value": [
+                    "default",
+                    "UTF16",
+                    "Base64"
+                ]
+            }
+        ]
+    },
     "Label": {
         "module": "Default",
         "description": "Provides a location for conditional and fixed jumps to redirect execution to.",
@@ -10271,6 +10338,16 @@
             }
         ]
     },
+    "ROT8000": {
+        "module": "Default",
+        "description": "The simple Caesar-cypher encryption that replaces each Unicode character with the one 0x8000 places forward or back along the alphabet.",
+        "infoURL": "https://rot8000.com/info",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": []
+    },
     "RSA Decrypt": {
         "module": "Ciphers",
         "description": "Decrypt an RSA encrypted message with a PEM encoded private key.",

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

@@ -17,6 +17,8 @@ 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 CetaceanCipherDecode from "../../operations/CetaceanCipherDecode.mjs";
+import CetaceanCipherEncode from "../../operations/CetaceanCipherEncode.mjs";
 import DESDecrypt from "../../operations/DESDecrypt.mjs";
 import DESEncrypt from "../../operations/DESEncrypt.mjs";
 import DeriveEVPKey from "../../operations/DeriveEVPKey.mjs";
@@ -55,6 +57,8 @@ OpModules.Ciphers = {
     "Blowfish Decrypt": BlowfishDecrypt,
     "Blowfish Encrypt": BlowfishEncrypt,
     "Caesar Box Cipher": CaesarBoxCipher,
+    "Cetacean Cipher Decode": CetaceanCipherDecode,
+    "Cetacean Cipher Encode": CetaceanCipherEncode,
     "DES Decrypt": DESDecrypt,
     "DES Encrypt": DESEncrypt,
     "Derive EVP key": DeriveEVPKey,

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

@@ -9,6 +9,8 @@ import Bzip2Compress from "../../operations/Bzip2Compress.mjs";
 import Bzip2Decompress from "../../operations/Bzip2Decompress.mjs";
 import Gunzip from "../../operations/Gunzip.mjs";
 import Gzip from "../../operations/Gzip.mjs";
+import LZStringCompress from "../../operations/LZStringCompress.mjs";
+import LZStringDecompress from "../../operations/LZStringDecompress.mjs";
 import RawDeflate from "../../operations/RawDeflate.mjs";
 import RawInflate from "../../operations/RawInflate.mjs";
 import Tar from "../../operations/Tar.mjs";
@@ -25,6 +27,8 @@ OpModules.Compression = {
     "Bzip2 Decompress": Bzip2Decompress,
     "Gunzip": Gunzip,
     "Gzip": Gzip,
+    "LZString Compress": LZStringCompress,
+    "LZString Decompress": LZStringDecompress,
     "Raw Deflate": RawDeflate,
     "Raw Inflate": RawInflate,
     "Tar": Tar,

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

@@ -110,6 +110,7 @@ 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 ROT8000 from "../../operations/ROT8000.mjs";
 import RemoveDiacritics from "../../operations/RemoveDiacritics.mjs";
 import RemoveLineNumbers from "../../operations/RemoveLineNumbers.mjs";
 import RemoveNullBytes from "../../operations/RemoveNullBytes.mjs";
@@ -282,6 +283,7 @@ OpModules.Default = {
     "ROT13 Brute Force": ROT13BruteForce,
     "ROT47": ROT47,
     "ROT47 Brute Force": ROT47BruteForce,
+    "ROT8000": ROT8000,
     "Remove Diacritics": RemoveDiacritics,
     "Remove line numbers": RemoveLineNumbers,
     "Remove null bytes": RemoveNullBytes,

package/src/core/lib/LZString.mjs

@@ -0,0 +1,21 @@
+/**
+ * lz-string exports.
+ *
+ * @author crespyl [peter@crespyl.net]
+ * @copyright Peter Jacobs 2021
+ * @license Apache-2.0
+ */
+
+import LZString from "lz-string";
+
+export const COMPRESSION_OUTPUT_FORMATS = ["default", "UTF16", "Base64"];
+export const COMPRESSION_FUNCTIONS = {
+    "default": LZString.compress,
+    "UTF16":   LZString.compressToUTF16,
+    "Base64":  LZString.compressToBase64,
+};
+export const DECOMPRESSION_FUNCTIONS = {
+    "default": LZString.decompress,
+    "UTF16":   LZString.decompressFromUTF16,
+    "Base64":  LZString.decompressFromBase64,
+};

package/src/core/operations/CetaceanCipherDecode.mjs

@@ -0,0 +1,63 @@
+/**
+ * @author dolphinOnKeys [robin@weird.io]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Cetacean Cipher Decode operation
+ */
+class CetaceanCipherDecode extends Operation {
+
+    /**
+     * CetaceanCipherDecode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Cetacean Cipher Decode";
+        this.module = "Ciphers";
+        this.description = "Decode Cetacean Cipher input. <br/><br/>e.g. <code>EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe</code> becomes <code>hi</code>";
+        this.infoURL = "https://hitchhikers.fandom.com/wiki/Dolphins";
+        this.inputType = "string";
+        this.outputType = "string";
+
+        this.checks = [
+            {
+                pattern: "^(?:[eE]{16,})(?: [eE]{16,})*$",
+                flags: "",
+                args: []
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const binaryArray = [];
+        for (const char of input) {
+            if (char === " ") {
+                binaryArray.push(...[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0]);
+            } else {
+                binaryArray.push(char === "e" ? 1 : 0);
+            }
+        }
+
+        const byteArray = [];
+
+        for (let i = 0;  i < binaryArray.length; i += 16) {
+            byteArray.push(binaryArray.slice(i, i + 16).join(""));
+        }
+
+        return byteArray.map(byte =>
+            String.fromCharCode(parseInt(byte, 2))
+        ).join("");
+    }
+}
+
+export default CetaceanCipherDecode;

package/src/core/operations/CetaceanCipherEncode.mjs

@@ -0,0 +1,51 @@
+/**
+ * @author dolphinOnKeys [robin@weird.io]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {toBinary} from "../lib/Binary.mjs";
+
+/**
+ * Cetacean Cipher Encode operation
+ */
+class CetaceanCipherEncode extends Operation {
+
+    /**
+     * CetaceanCipherEncode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Cetacean Cipher Encode";
+        this.module = "Ciphers";
+        this.description = "Converts any input into Cetacean Cipher. <br/><br/>e.g. <code>hi</code> becomes <code>EEEEEEEEEeeEeEEEEEEEEEEEEeeEeEEe</code>";
+        this.infoURL = "https://hitchhikers.fandom.com/wiki/Dolphins";
+        this.inputType = "string";
+        this.outputType = "string";
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const result = [];
+        const charArray = input.split("");
+
+        charArray.map(character => {
+            if (character === " ") {
+                result.push(character);
+            } else {
+                const binaryArray = toBinary(character.charCodeAt(0), "None", 16).split("");
+                result.push(binaryArray.map(str => str === "1" ? "e" : "E").join(""));
+            }
+        });
+
+        return result.join("");
+    }
+}
+
+export default CetaceanCipherEncode;

package/src/core/operations/LZStringCompress.mjs

@@ -0,0 +1,55 @@
+/**
+ * @author crespyl [peter@crespyl.net]
+ * @copyright Peter Jacobs 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+import {COMPRESSION_OUTPUT_FORMATS, COMPRESSION_FUNCTIONS} from "../lib/LZString.mjs";
+
+/**
+ * LZString Compress operation
+ */
+class LZStringCompress extends Operation {
+
+    /**
+     * LZStringCompress constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "LZString Compress";
+        this.module = "Compression";
+        this.description = "Compress the input with lz-string.";
+        this.infoURL = "https://pieroxy.net/blog/pages/lz-string/index.html";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Compression Format",
+                type: "option",
+                defaultIndex: 0,
+                value: COMPRESSION_OUTPUT_FORMATS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const compress = COMPRESSION_FUNCTIONS[args[0]];
+        if (compress) {
+            return compress(input);
+        } else {
+            throw new OperationError("Unable to find compression function");
+        }
+    }
+
+}
+
+export default LZStringCompress;

package/src/core/operations/LZStringDecompress.mjs

@@ -0,0 +1,56 @@
+/**
+ * @author crespyl [peter@crespyl.net]
+ * @copyright Peter Jacobs 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+import {COMPRESSION_OUTPUT_FORMATS, DECOMPRESSION_FUNCTIONS} from "../lib/LZString.mjs";
+
+/**
+ * LZString Decompress operation
+ */
+class LZStringDecompress extends Operation {
+
+    /**
+     * LZStringDecompress constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "LZString Decompress";
+        this.module = "Compression";
+        this.description = "Decompresses data that was compressed with lz-string.";
+        this.infoURL = "https://pieroxy.net/blog/pages/lz-string/index.html";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Compression Format",
+                type: "option",
+                defaultIndex: 0,
+                value: COMPRESSION_OUTPUT_FORMATS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const decompress = DECOMPRESSION_FUNCTIONS[args[0]];
+        if (decompress) {
+            return decompress(input);
+        } else {
+            throw new OperationError("Unable to find decompression function");
+        }
+    }
+
+
+}
+
+export default LZStringDecompress;

package/src/core/operations/ROT8000.mjs

@@ -0,0 +1,123 @@
+/**
+ * @author Daniel Temkin [http://danieltemkin.com]
+ * @author Thomas Leplus [https://www.leplus.org]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * ROT8000 operation.
+ */
+class ROT8000 extends Operation {
+
+    /**
+     * ROT8000 constructor
+     */
+    constructor() {
+        super();
+        this.name = "ROT8000";
+        this.module = "Default";
+        this.description = "The simple Caesar-cypher encryption that replaces each Unicode character with the one 0x8000 places forward or back along the alphabet.";
+        this.infoURL = "https://rot8000.com/info";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        // Inspired from https://github.com/rottytooth/rot8000/blob/main/rot8000.js
+        // these come from the valid-code-point-transitions.json file generated from the c# proj
+        // this is done bc: 1) don't trust JS's understanging of surrogate pairs and 2) consistency with original rot8000
+        const validCodePoints = {
+            "33": true,
+            "127": false,
+            "161": true,
+            "5760": false,
+            "5761": true,
+            "8192": false,
+            "8203": true,
+            "8232": false,
+            "8234": true,
+            "8239": false,
+            "8240": true,
+            "8287": false,
+            "8288": true,
+            "12288": false,
+            "12289": true,
+            "55296": false,
+            "57344": true
+        };
+        const bmpSize = 0x10000;
+        const rotList = {}; // the mapping of char to rotated char
+        const hiddenBlocks = [];
+        let startBlock = 0;
+        for (const key in validCodePoints) {
+            if (Object.prototype.hasOwnProperty.call(validCodePoints, key)) {
+                if (validCodePoints[key] === true)
+                    hiddenBlocks.push({ start: startBlock, end: parseInt(key, 10) - 1 });
+                else
+                    startBlock = parseInt(key, 10);
+            }
+        }
+        const validIntList = []; // list of all valid chars
+        let currValid = false;
+        for (let i = 0; i < bmpSize; i++) {
+            if (validCodePoints[i] !== undefined) {
+                currValid = validCodePoints[i];
+            }
+            if (currValid) validIntList.push(i);
+        }
+        const rotateNum = Object.keys(validIntList).length / 2;
+        // go through every valid char and find its match
+        for (let i = 0; i < validIntList.length; i++) {
+            rotList[String.fromCharCode(validIntList[i])] =
+                String.fromCharCode(validIntList[(i + rotateNum) % (rotateNum * 2)]);
+        }
+        let output = "";
+        for (let count = 0; count < input.length; count++) {
+            // if it is not in the mappings list, just add it directly (no rotation)
+            if (rotList[input[count]] === undefined) {
+                output += input[count];
+                continue;
+            }
+            // otherwise, rotate it and add it to the string
+            output += rotList[input[count]];
+        }
+        return output;
+    }
+
+    /**
+     * Highlight ROT8000
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlight(pos, args) {
+        return pos;
+    }
+
+    /**
+     * Highlight ROT8000 in reverse
+     *
+     * @param {Object[]} pos
+     * @param {number} pos[].start
+     * @param {number} pos[].end
+     * @param {Object[]} args
+     * @returns {Object[]} pos
+     */
+    highlightReverse(pos, args) {
+        return pos;
+    }
+}
+
+export default ROT8000;

package/src/core/operations/index.mjs

@@ -50,6 +50,8 @@ import CSVToJSON from "./CSVToJSON.mjs";
 import CTPH from "./CTPH.mjs";
 import CaesarBoxCipher from "./CaesarBoxCipher.mjs";
 import CartesianProduct from "./CartesianProduct.mjs";
+import CetaceanCipherDecode from "./CetaceanCipherDecode.mjs";
+import CetaceanCipherEncode from "./CetaceanCipherEncode.mjs";
 import ChangeIPFormat from "./ChangeIPFormat.mjs";
 import ChiSquare from "./ChiSquare.mjs";
 import CipherSaber2Decrypt from "./CipherSaber2Decrypt.mjs";
@@ -194,6 +196,8 @@ import Jump from "./Jump.mjs";
 import Keccak from "./Keccak.mjs";
 import LS47Decrypt from "./LS47Decrypt.mjs";
 import LS47Encrypt from "./LS47Encrypt.mjs";
+import LZStringCompress from "./LZStringCompress.mjs";
+import LZStringDecompress from "./LZStringDecompress.mjs";
 import Label from "./Label.mjs";
 import Lorenz from "./Lorenz.mjs";
 import LuhnChecksum from "./LuhnChecksum.mjs";
@@ -255,6 +259,7 @@ import ROT13 from "./ROT13.mjs";
 import ROT13BruteForce from "./ROT13BruteForce.mjs";
 import ROT47 from "./ROT47.mjs";
 import ROT47BruteForce from "./ROT47BruteForce.mjs";
+import ROT8000 from "./ROT8000.mjs";
 import RSADecrypt from "./RSADecrypt.mjs";
 import RSAEncrypt from "./RSAEncrypt.mjs";
 import RSASign from "./RSASign.mjs";
@@ -430,6 +435,8 @@ export {
     CTPH,
     CaesarBoxCipher,
     CartesianProduct,
+    CetaceanCipherDecode,
+    CetaceanCipherEncode,
     ChangeIPFormat,
     ChiSquare,
     CipherSaber2Decrypt,
@@ -574,6 +581,8 @@ export {
     Keccak,
     LS47Decrypt,
     LS47Encrypt,
+    LZStringCompress,
+    LZStringDecompress,
     Label,
     Lorenz,
     LuhnChecksum,
@@ -635,6 +644,7 @@ export {
     ROT13BruteForce,
     ROT47,
     ROT47BruteForce,
+    ROT8000,
     RSADecrypt,
     RSAEncrypt,
     RSASign,

package/src/node/index.mjs

@@ -60,6 +60,8 @@ import {
     CTPH as core_CTPH,
     CaesarBoxCipher as core_CaesarBoxCipher,
     CartesianProduct as core_CartesianProduct,
+    CetaceanCipherDecode as core_CetaceanCipherDecode,
+    CetaceanCipherEncode as core_CetaceanCipherEncode,
     ChangeIPFormat as core_ChangeIPFormat,
     ChiSquare as core_ChiSquare,
     CipherSaber2Decrypt as core_CipherSaber2Decrypt,
@@ -197,6 +199,8 @@ import {
     Keccak as core_Keccak,
     LS47Decrypt as core_LS47Decrypt,
     LS47Encrypt as core_LS47Encrypt,
+    LZStringCompress as core_LZStringCompress,
+    LZStringDecompress as core_LZStringDecompress,
     Lorenz as core_Lorenz,
     LuhnChecksum as core_LuhnChecksum,
     MD2 as core_MD2,
@@ -256,6 +260,7 @@ import {
     ROT13BruteForce as core_ROT13BruteForce,
     ROT47 as core_ROT47,
     ROT47BruteForce as core_ROT47BruteForce,
+    ROT8000 as core_ROT8000,
     RSADecrypt as core_RSADecrypt,
     RSAEncrypt as core_RSAEncrypt,
     RSASign as core_RSASign,
@@ -440,6 +445,8 @@ function generateChef() {
         "CTPH": _wrap(core_CTPH),
         "caesarBoxCipher": _wrap(core_CaesarBoxCipher),
         "cartesianProduct": _wrap(core_CartesianProduct),
+        "cetaceanCipherDecode": _wrap(core_CetaceanCipherDecode),
+        "cetaceanCipherEncode": _wrap(core_CetaceanCipherEncode),
         "changeIPFormat": _wrap(core_ChangeIPFormat),
         "chiSquare": _wrap(core_ChiSquare),
         "cipherSaber2Decrypt": _wrap(core_CipherSaber2Decrypt),
@@ -577,6 +584,8 @@ function generateChef() {
         "keccak": _wrap(core_Keccak),
         "LS47Decrypt": _wrap(core_LS47Decrypt),
         "LS47Encrypt": _wrap(core_LS47Encrypt),
+        "LZStringCompress": _wrap(core_LZStringCompress),
+        "LZStringDecompress": _wrap(core_LZStringDecompress),
         "lorenz": _wrap(core_Lorenz),
         "luhnChecksum": _wrap(core_LuhnChecksum),
         "MD2": _wrap(core_MD2),
@@ -636,6 +645,7 @@ function generateChef() {
         "ROT13BruteForce": _wrap(core_ROT13BruteForce),
         "ROT47": _wrap(core_ROT47),
         "ROT47BruteForce": _wrap(core_ROT47BruteForce),
+        "ROT8000": _wrap(core_ROT8000),
         "RSADecrypt": _wrap(core_RSADecrypt),
         "RSAEncrypt": _wrap(core_RSAEncrypt),
         "RSASign": _wrap(core_RSASign),
@@ -828,6 +838,8 @@ const CSVToJSON = chef.CSVToJSON;
 const CTPH = chef.CTPH;
 const caesarBoxCipher = chef.caesarBoxCipher;
 const cartesianProduct = chef.cartesianProduct;
+const cetaceanCipherDecode = chef.cetaceanCipherDecode;
+const cetaceanCipherEncode = chef.cetaceanCipherEncode;
 const changeIPFormat = chef.changeIPFormat;
 const chiSquare = chef.chiSquare;
 const cipherSaber2Decrypt = chef.cipherSaber2Decrypt;
@@ -972,6 +984,8 @@ const jump = chef.jump;
 const keccak = chef.keccak;
 const LS47Decrypt = chef.LS47Decrypt;
 const LS47Encrypt = chef.LS47Encrypt;
+const LZStringCompress = chef.LZStringCompress;
+const LZStringDecompress = chef.LZStringDecompress;
 const label = chef.label;
 const lorenz = chef.lorenz;
 const luhnChecksum = chef.luhnChecksum;
@@ -1033,6 +1047,7 @@ const ROT13 = chef.ROT13;
 const ROT13BruteForce = chef.ROT13BruteForce;
 const ROT47 = chef.ROT47;
 const ROT47BruteForce = chef.ROT47BruteForce;
+const ROT8000 = chef.ROT8000;
 const RSADecrypt = chef.RSADecrypt;
 const RSAEncrypt = chef.RSAEncrypt;
 const RSASign = chef.RSASign;
@@ -1210,6 +1225,8 @@ const operations = [
     CTPH,
     caesarBoxCipher,
     cartesianProduct,
+    cetaceanCipherDecode,
+    cetaceanCipherEncode,
     changeIPFormat,
     chiSquare,
     cipherSaber2Decrypt,
@@ -1354,6 +1371,8 @@ const operations = [
     keccak,
     LS47Decrypt,
     LS47Encrypt,
+    LZStringCompress,
+    LZStringDecompress,
     label,
     lorenz,
     luhnChecksum,
@@ -1415,6 +1434,7 @@ const operations = [
     ROT13BruteForce,
     ROT47,
     ROT47BruteForce,
+    ROT8000,
     RSADecrypt,
     RSAEncrypt,
     RSASign,
@@ -1596,6 +1616,8 @@ export {
     CTPH,
     caesarBoxCipher,
     cartesianProduct,
+    cetaceanCipherDecode,
+    cetaceanCipherEncode,
     changeIPFormat,
     chiSquare,
     cipherSaber2Decrypt,
@@ -1740,6 +1762,8 @@ export {
     keccak,
     LS47Decrypt,
     LS47Encrypt,
+    LZStringCompress,
+    LZStringDecompress,
     label,
     lorenz,
     luhnChecksum,
@@ -1801,6 +1825,7 @@ export {
     ROT13BruteForce,
     ROT47,
     ROT47BruteForce,
+    ROT8000,
     RSADecrypt,
     RSAEncrypt,
     RSASign,

package/tests/browser/ops.js

@@ -249,6 +249,7 @@ module.exports = {
         // testOp(browser, "RIPEMD", "test input", "test_output");
         // testOp(browser, "ROT13", "test input", "test_output");
         // testOp(browser, "ROT47", "test input", "test_output");
+        // testOp(browser, "ROT8000", "test input", "test_output");
         // testOp(browser, "Rail Fence Cipher Decode", "test input", "test_output");
         // testOp(browser, "Rail Fence Cipher Encode", "test input", "test_output");
         // testOp(browser, "Randomize Colour Palette", "test input", "test_output");

package/tests/operations/index.mjs

@@ -28,6 +28,8 @@ import "./tests/Base85.mjs";
 import "./tests/BitwiseOp.mjs";
 import "./tests/ByteRepr.mjs";
 import "./tests/CartesianProduct.mjs";
+import "./tests/CetaceanCipherEncode.mjs";
+import "./tests/CetaceanCipherDecode.mjs";
 import "./tests/CharEnc.mjs";
 import "./tests/ChangeIPFormat.mjs";
 import "./tests/Charts.mjs";
@@ -118,6 +120,7 @@ import "./tests/ELFInfo.mjs";
 import "./tests/Subsection.mjs";
 import "./tests/CaesarBoxCipher.mjs";
 import "./tests/LS47.mjs";
+import "./tests/LZString.mjs";
 
 
 // Cannot test operations that use the File type yet

package/tests/operations/tests/CetaceanCipherDecode.mjs

@@ -0,0 +1,22 @@
+/**
+ * CetaceanCipher Encode tests
+ *
+ * @author dolphinOnKeys
+ * @copyright Crown Copyright 2022
+ * @licence Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "Cetacean Cipher Decode",
+        input: "EEEEEEEEEeeEEEEe EEEEEEEEEeeEEEeE EEEEEEEEEeeEEEee EEeeEEEEEeeEEeee",
+        expectedOutput: "a b c で",
+        recipeConfig: [
+            {
+                op: "Cetacean Cipher Decode",
+                args: []
+            },
+        ],
+    }
+]);

package/tests/operations/tests/CetaceanCipherEncode.mjs

@@ -0,0 +1,22 @@
+/**
+ * CetaceanCipher Encode tests
+ *
+ * @author dolphinOnKeys
+ * @copyright Crown Copyright 2022
+ * @licence Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "Cetacean Cipher Encode",
+        input: "a b c で",
+        expectedOutput: "EEEEEEEEEeeEEEEe EEEEEEEEEeeEEEeE EEEEEEEEEeeEEEee EEeeEEEEEeeEEeee",
+        recipeConfig: [
+            {
+                op: "Cetacean Cipher Encode",
+                args: []
+            },
+        ],
+    }
+]);

package/tests/operations/tests/LZString.mjs

@@ -0,0 +1,33 @@
+/**
+ * LZString tests.
+ *
+ * @author crespyl [peter@crespyl.net]
+ * @copyright Peter Jacobs 2021
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "LZString Compress To Base64",
+        input: "hello world",
+        expectedOutput: "BYUwNmD2AEDukCcwBMg=",
+        recipeConfig: [
+            {
+                "op": "LZString Compress",
+                "args": ["Base64"]
+            }
+        ],
+    },
+    {
+        name: "LZString Decompress From Base64",
+        input: "BYUwNmD2AEDukCcwBMg=",
+        expectedOutput: "hello world",
+        recipeConfig: [
+            {
+                "op": "LZString Decompress",
+                "args": ["Base64"]
+            }
+        ],
+    }
+]);

package/tests/operations/tests/Rotate.mjs

@@ -212,4 +212,37 @@ TestRegister.addTests([
             },
         ],
     },
+    {
+        name: "ROT8000: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "ROT8000",
+                args: []
+            },
+        ],
+    },
+    {
+        name: "ROT8000: normal",
+        input: "The Quick Brown Fox Jumped Over The Lazy Dog.",
+        expectedOutput: "籝籱籮 籚籾籲籬籴 籋类籸粀籷 籏籸粁 籓籾籶籹籮籭 籘籿籮类 籝籱籮 籕籪粃粂 籍籸籰簷",
+        recipeConfig: [
+            {
+                op: "ROT8000",
+                args: []
+            },
+        ],
+    },
+    {
+        name: "ROT8000: backward",
+        input: "籝籱籮 籚籾籲籬籴 籋类籸粀籷 籏籸粁 籓籾籶籹籮籭 籘籿籮类 籝籱籮 籕籪粃粂 籍籸籰簷",
+        expectedOutput: "The Quick Brown Fox Jumped Over The Lazy Dog.",
+        recipeConfig: [
+            {
+                op: "ROT8000",
+                args: []
+            },
+        ],
+    },
 ]);