Merge branch 'master' into date-delta

2024-04-01 23:32:13 +03:00 · 2024-04-01 23:32:13 +03:00 · dd2cfe8bac
parent dfedfa9f4c 8a17abae45
commit dd2cfe8bac
24 changed files with 781 additions and 27 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -13,6 +13,16 @@ All major and minor version changes will be documented in this file. Details of

 ## Details

+### [10.14.0] - 2024-03-31
+- Added 'To Float' and 'From Float' operations [@tcode2k16] | [#1762]
+- Fix ChaCha raw export option [@joostrijneveld] | [#1606]
+- Update x86 disassembler vendor library [@evanreichard] | [#1197]
+- Allow variable Blowfish key sizes [@cbeuw] | [#933]
+- Added 'XXTEA' operation [@devcydo] | [#1361]
+
+### [10.13.0] - 2024-03-30
+- Added 'FangURL' operation [@breakersall] [@arnydo] | [#1591] [#654]
+
 ### [10.12.0] - 2024-03-29
 - Added 'Salsa20' and 'XSalsa20' operation [@joostrijneveld] | [#1750]

@ -400,6 +410,8 @@ All major and minor version changes will be documented in this file. Details of
 ## [4.0.0] - 2016-11-28
 -  Initial open source commit [@n1474335] | [b1d73a72](https://github.com/gchq/CyberChef/commit/b1d73a725dc7ab9fb7eb789296efd2b7e4b08306)

+[10.14.0]: https://github.com/gchq/CyberChef/releases/tag/v10.14.0
+[10.13.0]: https://github.com/gchq/CyberChef/releases/tag/v10.13.0
 [10.12.0]: https://github.com/gchq/CyberChef/releases/tag/v10.12.0
 [10.11.0]: https://github.com/gchq/CyberChef/releases/tag/v10.11.0
 [10.10.0]: https://github.com/gchq/CyberChef/releases/tag/v10.10.0
@ -571,6 +583,9 @@ All major and minor version changes will be documented in this file. Details of
 [@AshCorr]: https://github.com/AshCorr
 [@simonw]: https://github.com/simonw
 [@chriswhite199]: https://github.com/chriswhite199
+[@breakersall]: https://github.com/breakersall
+[@evanreichard]: https://github.com/evanreichard
+[@devcydo]: https://github.com/devcydo


 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
@ -703,3 +718,10 @@ All major and minor version changes will be documented in this file. Details of
 [#1752]: https://github.com/gchq/CyberChef/issues/1752
 [#1753]: https://github.com/gchq/CyberChef/issues/1753
 [#1750]: https://github.com/gchq/CyberChef/issues/1750
+[#1591]: https://github.com/gchq/CyberChef/issues/1591
+[#654]: https://github.com/gchq/CyberChef/issues/654
+[#1762]: https://github.com/gchq/CyberChef/issues/1762
+[#1606]: https://github.com/gchq/CyberChef/issues/1606
+[#1197]: https://github.com/gchq/CyberChef/issues/1197
+[#933]: https://github.com/gchq/CyberChef/issues/933
+[#1361]: https://github.com/gchq/CyberChef/issues/1361
--- a/package-lock.json
+++ b/package-lock.json
@ -1,12 +1,12 @@
 {
  "name": "cyberchef",
-  "version": "10.10.0",
+  "version": "10.14.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "cyberchef",
-      "version": "10.10.0",
+      "version": "10.14.0",
      "hasInstallScript": true,
      "license": "Apache-2.0",
      "dependencies": {
@ -46,6 +46,7 @@
        "flat": "^6.0.1",
        "geodesy": "1.1.3",
        "highlight.js": "^11.9.0",
+        "ieee754": "^1.1.13",
        "jimp": "^0.16.13",
        "jquery": "3.7.1",
        "js-crc": "^0.2.0",
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "cyberchef",
-  "version": "10.12.1",
+  "version": "10.14.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",
@ -122,6 +122,7 @@
    "escodegen": "^2.1.0",
    "esprima": "^4.0.1",
    "exif-parser": "^0.1.12",
+    "ieee754": "^1.1.13",
    "fernet": "^0.3.2",
    "file-saver": "^2.0.5",
    "flat": "^6.0.1",
--- a/src/core/config/Categories.json
+++ b/src/core/config/Categories.json
@ -14,6 +14,8 @@
            "From Charcode",
            "To Decimal",
            "From Decimal",
+            "To Float",
+            "From Float",
            "To Binary",
            "From Binary",
            "To Octal",
@ -153,7 +155,8 @@
            "Typex",
            "Lorenz",
            "Colossus",
-            "SIGABA"
+            "SIGABA",
+            "XXTEA"
        ]
    },
    {
@ -242,6 +245,7 @@
            "Encode NetBIOS Name",
            "Decode NetBIOS Name",
            "Defang URL",
+            "Fang URL",
            "Defang IP Addresses"
        ]
    },
--- a/src/core/lib/CipherSaber2.mjs
+++ b/src/core/lib/CipherSaber2.mjs
@ -4,7 +4,7 @@
 * @license Apache-2.0
 */
 export function encode(tempIVP, key, rounds, input) {
-    const ivp = new Uint8Array(key.concat(tempIVP));
+    const ivp = new Uint8Array([...key, ...tempIVP]);
    const state = new Array(256).fill(0);
    let j = 0, i = 0;
    const result = [];
--- a/src/core/operations/BlowfishDecrypt.mjs
+++ b/src/core/operations/BlowfishDecrypt.mjs
@ -70,10 +70,14 @@ class BlowfishDecrypt extends Operation {
            inputType = args[3],
            outputType = args[4];

-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
            throw new OperationError(`Invalid key length: ${key.length} bytes

-Blowfish uses a key length of 8 bytes (64 bits).`);
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }
+
+        if (iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes`);
        }

        input = Utils.convertToByteString(input, inputType);
--- a/src/core/operations/BlowfishEncrypt.mjs
+++ b/src/core/operations/BlowfishEncrypt.mjs
@ -70,10 +70,14 @@ class BlowfishEncrypt extends Operation {
            inputType = args[3],
            outputType = args[4];

-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
            throw new OperationError(`Invalid key length: ${key.length} bytes
+    
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }

-Blowfish uses a key length of 8 bytes (64 bits).`);
+        if (iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes`);
        }

        input = Utils.convertToByteString(input, inputType);
--- a/src/core/operations/ChaCha.mjs
+++ b/src/core/operations/ChaCha.mjs
@ -191,7 +191,7 @@ ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`);
        if (outputType === "Hex") {
            return toHex(output);
        } else {
-            return Utils.arrayBufferToStr(output);
+            return Utils.arrayBufferToStr(Uint8Array.from(output).buffer);
        }
    }

--- a/src/core/operations/FangURL.mjs
+++ b/src/core/operations/FangURL.mjs
@ -0,0 +1,77 @@
+/**
+ * @author arnydo [github@arnydo.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * FangURL operation
+ */
+class FangURL extends Operation {
+
+    /**
+     * FangURL constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fang URL";
+        this.module = "Default";
+        this.description = "Takes a 'Defanged' Universal Resource Locator (URL) and 'Fangs' it. Meaning, it removes the alterations (defanged) that render it useless so that it can be used again.";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Restore [.]",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore hxxp",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore ://",
+                type: "boolean",
+                value: true
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [dots, http, slashes] = args;
+
+        input = fangURL(input, dots, http, slashes);
+
+        return input;
+    }
+
+}
+
+
+/**
+ * Defangs a given URL
+ *
+ * @param {string} url
+ * @param {boolean} dots
+ * @param {boolean} http
+ * @param {boolean} slashes
+ * @returns {string}
+ */
+function fangURL(url, dots, http, slashes) {
+    if (dots) url = url.replace(/\[\.\]/g, ".");
+    if (http) url = url.replace(/hxxp/g, "http");
+    if (slashes) url = url.replace(/\[:\/\/\]/g, "://");
+
+    return url;
+}
+
+export default FangURL;
--- a/src/core/operations/FromBase58.mjs
+++ b/src/core/operations/FromBase58.mjs
@ -60,7 +60,7 @@ class FromBase58 extends Operation {
    run(input, args) {
        let alphabet = args[0] || ALPHABET_OPTIONS[0].value;
        const removeNonAlphaChars = args[1] === undefined ? true : args[1],
-            result = [0];
+            result = [];

        alphabet = Utils.expandAlphRange(alphabet).join("");

@ -87,11 +87,9 @@ class FromBase58 extends Operation {
                }
            }

-            let carry = result[0] * 58 + index;
-            result[0] = carry & 0xFF;
-            carry = carry >> 8;
+            let carry = index;

-            for (let i = 1; i < result.length; i++) {
+            for (let i = 0; i < result.length; i++) {
                carry += result[i] * 58;
                result[i] = carry & 0xFF;
                carry = carry >> 8;
--- a/src/core/operations/FromFloat.mjs
+++ b/src/core/operations/FromFloat.mjs
@ -0,0 +1,78 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import ieee754 from "ieee754";
+import {DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * From Float operation
+ */
+class FromFloat extends Operation {
+
+    /**
+     * FromFloat constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Float";
+        this.module = "Default";
+        this.description = "Convert from EEE754 Floating Point Numbers";
+        this.infoURL = "https://en.wikipedia.org/wiki/IEEE_754";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big Endian",
+                    "Little Endian"
+                ]
+            },
+            {
+                "name": "Size",
+                "type": "option",
+                "value": [
+                    "Float (4 bytes)",
+                    "Double (8 bytes)"
+                ]
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        if (input.length === 0) return [];
+
+        const [endianness, size, delimiterName] = args;
+        const delim = Utils.charRep(delimiterName || "Space");
+        const byteSize = size === "Double (8 bytes)" ? 8 : 4;
+        const isLE = endianness === "Little Endian";
+        const mLen = byteSize === 4 ? 23 : 52;
+        const floats = input.split(delim);
+
+        const output = new Array(floats.length*byteSize);
+        for (let i = 0; i < floats.length; i++) {
+            ieee754.write(output, parseFloat(floats[i]), i*byteSize, isLE, mLen, byteSize);
+        }
+        return output;
+    }
+
+}
+
+export default FromFloat;
--- a/src/core/operations/ToBase58.mjs
+++ b/src/core/operations/ToBase58.mjs
@ -43,7 +43,7 @@ class ToBase58 extends Operation {
    run(input, args) {
        input = new Uint8Array(input);
        let alphabet = args[0] || ALPHABET_OPTIONS[0].value,
-            result = [0];
+            result = [];

        alphabet = Utils.expandAlphRange(alphabet).join("");

@ -60,11 +60,9 @@ class ToBase58 extends Operation {
        }

        input.forEach(function(b) {
-            let carry = (result[0] << 8) + b;
-            result[0] = carry % 58;
-            carry = (carry / 58) | 0;
+            let carry = b;

-            for (let i = 1; i < result.length; i++) {
+            for (let i = 0; i < result.length; i++) {
                carry += result[i] << 8;
                result[i] = carry % 58;
                carry = (carry / 58) | 0;
--- a/src/core/operations/ToFloat.mjs
+++ b/src/core/operations/ToFloat.mjs
@ -0,0 +1,80 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import ieee754 from "ieee754";
+import {DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * To Float operation
+ */
+class ToFloat extends Operation {
+
+    /**
+     * ToFloat constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "To Float";
+        this.module = "Default";
+        this.description = "Convert to EEE754 Floating Point Numbers";
+        this.infoURL = "https://en.wikipedia.org/wiki/IEEE_754";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big Endian",
+                    "Little Endian"
+                ]
+            },
+            {
+                "name": "Size",
+                "type": "option",
+                "value": [
+                    "Float (4 bytes)",
+                    "Double (8 bytes)"
+                ]
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [endianness, size, delimiterName] = args;
+        const delim = Utils.charRep(delimiterName || "Space");
+        const byteSize = size === "Double (8 bytes)" ? 8 : 4;
+        const isLE = endianness === "Little Endian";
+        const mLen = byteSize === 4 ? 23 : 52;
+
+        if (input.length % byteSize !== 0) {
+            throw new OperationError(`Input is not a multiple of ${byteSize}`);
+        }
+
+        const output = [];
+        for (let i = 0; i < input.length; i+=byteSize) {
+            output.push(ieee754.read(input, i, isLE, mLen, byteSize));
+        }
+        return output.join(delim);
+    }
+
+}
+
+export default ToFloat;
--- a/src/core/operations/XXTEA.mjs
+++ b/src/core/operations/XXTEA.mjs
@ -0,0 +1,182 @@
+/**
+ * @author devcydo [devcydo@gmail.com]
+ * @author Ma Bingyao [mabingyao@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import {toBase64} from "../lib/Base64.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * XXTEA Encrypt operation
+ */
+class XXTEAEncrypt extends Operation {
+
+    /**
+     * XXTEAEncrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "XXTEA";
+        this.module = "Default";
+        this.description = "Corrected Block TEA (often referred to as XXTEA) is a block cipher designed to correct weaknesses in the original Block TEA. XXTEA operates on variable-length blocks that are some arbitrary multiple of 32 bits in size (minimum 64 bits). The number of full cycles depends on the block size, but there are at least six (rising to 32 for small block sizes). The original Block TEA applies the XTEA round function to each word in the block and combines it additively with its leftmost neighbour. Slow diffusion rate of the decryption process was immediately exploited to break the cipher. Corrected Block TEA uses a more involved round function which makes use of both immediate neighbours in processing each word in the block.";
+        this.infoURL = "https://wikipedia.org/wiki/XXTEA";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "string",
+                "value": "",
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        let key = args[0];
+
+        if (input === undefined || input === null || input.length === 0) {
+            throw new OperationError("Invalid input length (0)");
+        }
+
+        if (key === undefined || key === null || key.length === 0) {
+            throw new OperationError("Invalid key length (0)");
+        }
+
+        input = Utils.convertToByteString(input, "utf8");
+        key = Utils.convertToByteString(key, "utf8");
+
+        input = this.convertToUint32Array(input, true);
+        key = this.fixLength(this.convertToUint32Array(key, false));
+
+        let encrypted = this.encryptUint32Array(input, key);
+
+        encrypted = toBase64(this.toBinaryString(encrypted, false));
+
+        return encrypted;
+    }
+
+    /**
+     * Convert Uint32Array to binary string
+     *
+     * @param {Uint32Array} v
+     * @param {Boolean} includeLength
+     * @returns {string}
+     */
+    toBinaryString(v, includeLENGTH) {
+        const LENGTH = v.length;
+        let n = LENGTH << 2;
+        if (includeLENGTH) {
+            const M = v[LENGTH - 1];
+            n -= 4;
+            if ((M < n - 3) || (M > n)) {
+                return null;
+            }
+            n = M;
+        }
+        for (let i = 0; i < LENGTH; i++) {
+            v[i] = String.fromCharCode(
+                v[i] & 0xFF,
+                v[i] >>> 8 & 0xFF,
+                v[i] >>> 16 & 0xFF,
+                v[i] >>> 24 & 0xFF
+            );
+        }
+        const RESULT = v.join("");
+        if (includeLENGTH) {
+            return RESULT.substring(0, n);
+        }
+        return RESULT;
+    }
+
+    /**
+     * @param {number} sum
+     * @param {number} y
+     * @param {number} z
+     * @param {number} p
+     * @param {number} e
+     * @param {number} k
+     * @returns {number}
+     */
+    mx(sum, y, z, p, e, k) {
+        return ((z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4)) ^ ((sum ^ y) + (k[p & 3 ^ e] ^ z));
+    }
+
+
+    /**
+     * Encrypt Uint32Array
+     *
+     * @param {Uint32Array} v
+     * @param {number} k
+     * @returns {Uint32Array}
+     */
+    encryptUint32Array(v, k) {
+        const LENGTH = v.length;
+        const N = LENGTH - 1;
+        let y, z, sum, e, p, q;
+        z = v[N];
+        sum = 0;
+        for (q = Math.floor(6 + 52 / LENGTH) | 0; q > 0; --q) {
+            sum = (sum + 0x9E3779B9) & 0xFFFFFFFF;
+            e = sum >>> 2 & 3;
+            for (p = 0; p < N; ++p) {
+                y = v[p + 1];
+                z = v[p] = (v[p] + this.mx(sum, y, z, p, e, k)) & 0xFFFFFFFF;
+            }
+            y = v[0];
+            z = v[N] = (v[N] + this.mx(sum, y, z, N, e, k)) & 0xFFFFFFFF;
+        }
+        return v;
+    }
+
+    /**
+     * Fixes the Uint32Array lenght to 4
+     *
+     * @param {Uint32Array} k
+     * @returns {Uint32Array}
+     */
+    fixLength(k) {
+        if (k.length < 4) {
+            k.length = 4;
+        }
+        return k;
+    }
+
+    /**
+     * Convert string to Uint32Array
+     *
+     * @param {string} bs
+     * @param {Boolean} includeLength
+     * @returns {Uint32Array}
+     */
+    convertToUint32Array(bs, includeLength) {
+        const LENGTH = bs.length;
+        let n = LENGTH >> 2;
+        if ((LENGTH & 3) !== 0) {
+            ++n;
+        }
+        let v;
+        if (includeLength) {
+            v = new Array(n + 1);
+            v[n] = LENGTH;
+        } else {
+            v = new Array(n);
+        }
+        for (let i = 0; i < LENGTH; ++i) {
+            v[i >> 2] |= bs.charCodeAt(i) << ((i & 3) << 3);
+        }
+        return v;
+    }
+
+}
+
+export default XXTEAEncrypt;
--- a/src/core/vendor/DisassembleX86-64.mjs
+++ b/src/core/vendor/DisassembleX86-64.mjs
@ -4054,7 +4054,7 @@ function DecodeImmediate( type, BySize, SizeSetting )
    
    //Sign bit adjust.
    
-    if( V32 >= ( n >> 1 ) ) { V32 -= n; }
+    if( V32 >= ( n / 2 ) ) { V32 -= n; }
    
    //Add position.
    
--- a/tests/browser/02_ops.js
+++ b/tests/browser/02_ops.js
@ -126,8 +126,8 @@ module.exports = {
        // testOp(browser, "Extract email addresses", "test input", "test_output");
        // testOp(browser, "Extract file paths", "test input", "test_output");
        testOpFile(browser, "Extract Files", "files/Hitchhikers_Guide.jpeg", ".card:last-child .collapsed", "extracted_at_0x3d38.zlib");
-        testOpFile(browser, "Extract ID3", "files/mp3example.mp3", "tr:last-child td:last-child", "Kevin MacLeod");
-        // testOp(browser, "Extract IP addresses", "test input", "test_output");
+        // This test seems unreliable on GitHub Actions, not reproducible locally.
+        // testOpFile(browser, "Extract ID3", "files/mp3example.mp3", "tr:last-child td:last-child", "Kevin MacLeod");        // testOp(browser, "Extract IP addresses", "test input", "test_output");
        // testOp(browser, "Extract LSB", "test input", "test_output");
        // testOp(browser, "Extract MAC addresses", "test input", "test_output");
        // testOp(browser, "Extract RGBA", "test input", "test_output");
--- a/tests/node/tests/operations.mjs
+++ b/tests/node/tests/operations.mjs
@ -432,7 +432,7 @@ color: white;
    it("Disassemble x86", () => {
        const result = chef.disassembleX86(chef.toBase64("one two three"));
        const expected = `0000000000000000 0000                            ADD BYTE PTR [RAX],AL\r
-0000000000000002 0B250000000B                    OR ESP,DWORD PTR [0000000-F4FFFFF8]\r
+0000000000000002 0B250000000B                    OR ESP,DWORD PTR [000000000B000008]\r
 `;
        assert.strictEqual(result.toString(), expected);
    }),
--- a/tests/operations/index.mjs
+++ b/tests/operations/index.mjs
@ -62,6 +62,7 @@ import "./tests/DefangIP.mjs";
 import "./tests/ELFInfo.mjs";
 import "./tests/Enigma.mjs";
 import "./tests/ExtractEmailAddresses.mjs";
+import "./tests/Float.mjs";
 import "./tests/FileTree.mjs";
 import "./tests/FletcherChecksum.mjs";
 import "./tests/Fork.mjs";
--- a/tests/operations/tests/Base58.mjs
+++ b/tests/operations/tests/Base58.mjs
@ -53,6 +53,28 @@ TestRegister.addTests([
            },
        ],
    },
+    {
+        name: "To Base58 all null",
+        input: "\0\0\0\0\0\0",
+        expectedOutput: "111111",
+        recipeConfig: [
+            {
+                op: "To Base58",
+                args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"],
+            },
+        ],
+    },
+    {
+        name: "From Base58 all null",
+        input: "111111",
+        expectedOutput: "\0\0\0\0\0\0",
+        recipeConfig: [
+            {
+                op: "From Base58",
+                args: ["123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"],
+            },
+        ],
+    },
    {
        name: "To Base58 with null prefix and suffix",
        input: "\0\0\0Hello\0\0\0",
--- a/tests/operations/tests/ChaCha.mjs
+++ b/tests/operations/tests/ChaCha.mjs
@ -58,6 +58,25 @@ ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`,
            }
        ],
    },
+    {
+        name: "ChaCha: RFC8439 Raw output",
+        input: "Ladies and Gentlemen of the class of '99: If I could offer you only one tip for the future, sunscreen would be it.",
+        expectedOutput: "6e 2e 35 9a 25 68 f9 80 41 ba 07 28 dd 0d 69 81 e9 7e 7a ec 1d 43 60 c2 0a 27 af cc fd 9f ae 0b f9 1b 65 c5 52 47 33 ab 8f 59 3d ab cd 62 b3 57 16 39 d6 24 e6 51 52 ab 8f 53 0c 35 9f 08 61 d8 07 ca 0d bf 50 0d 6a 61 56 a3 8e 08 8a 22 b6 5e 52 bc 51 4d 16 cc f8 06 81 8c e9 1a b7 79 37 36 5a f9 0b bf 74 a3 5b e6 b4 0b 8e ed f2 78 5e 42 87 4d",
+        recipeConfig: [
+            {
+                "op": "ChaCha",
+                "args": [
+                    {"option": "Hex", "string": "00:01:02:03:04:05:06:07:08:09:0a:0b:0c:0d:0e:0f:10:11:12:13:14:15:16:17:18:19:1a:1b:1c:1d:1e:1f"},
+                    {"option": "Hex", "string": "00:00:00:00:00:00:00:4a:00:00:00:00"},
+                    1, "20", "Raw", "Raw",
+                ]
+            },
+            {
+                "op": "To Hex",
+                "args": []
+            },
+        ],
+    },
    {
        name: "ChaCha: draft-strombergson-chacha-test-vectors-01 TC7.1",
        input: "00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00",
--- a/tests/operations/tests/CipherSaber2.mjs
+++ b/tests/operations/tests/CipherSaber2.mjs
@ -21,13 +21,16 @@ TestRegister.addTests([
        ],
    },
    {
+        // input taken from https://ciphersaber.gurus.org/
        name: "CipherSaber2 Decrypt",
-        input: "\x5d\xd9\x7f\xeb\x77\x3c\x42\x9d\xfe\x9c\x3b\x21\x63\xbd\x53\x38\x18\x7c\x36\x37",
-        expectedOutput: "helloworld",
+        input: "\x6f\x6d\x0b\xab\xf3\xaa\x67\x19\x03\x15\x30\xed\xb6\x77"  +
+            "\xca\x74\xe0\x08\x9d\xd0\xe7\xb8\x85\x43\x56\xbb\x14\x48\xe3" +
+            "\x7c\xdb\xef\xe7\xf3\xa8\x4f\x4f\x5f\xb3\xfd",
+        expectedOutput: "This is a test of CipherSaber.",
        recipeConfig: [
            {
                op: "CipherSaber2 Decrypt",
-                args: [{ "option": "Latin1", "string": "test" }, 20],
+                args: [{ "option": "Latin1", "string": "asdfg" }, 1],
            },
        ],
    },
--- a/tests/operations/tests/Crypt.mjs
+++ b/tests/operations/tests/Crypt.mjs
@ -1948,4 +1948,38 @@ DES uses a key length of 8 bytes (64 bits).`,
            }
        ],
    },
+    {
+        name: "Blowfish Encrypt with variable key length: CBC, ASCII, 4 bytes",
+        input: "The quick brown fox jumps over the lazy dog.",
+        expectedOutput: "823f337a53ecf121aa9ec1b111bd5064d1d7586abbdaaa0c8fd0c6cc43c831c88bf088ee3e07287e3f36cf2e45f9c7e6",
+        recipeConfig: [
+            {
+                "op": "Blowfish Encrypt",
+                "args": [
+                    {"option": "Hex", "string": "00112233"}, // Key
+                    {"option": "Hex", "string": "0000000000000000"}, // IV
+                    "CBC", // Mode
+                    "Raw", // Input
+                    "Hex" // Output
+                ]
+            }
+        ],
+    },
+    {
+        name: "Blowfish Encrypt with variable key length: CBC, ASCII, 42 bytes",
+        input: "The quick brown fox jumps over the lazy dog.",
+        expectedOutput: "19f5a68145b34321cfba72226b0f33922ce44dd6e7869fe328db64faae156471216f12ed2a37fd0bdd7cebf867b3cff0",
+        recipeConfig: [
+            {
+                "op": "Blowfish Encrypt",
+                "args": [
+                    {"option": "Hex", "string": "deadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdeadbeefdead"}, // Key
+                    {"option": "Hex", "string": "0000000000000000"}, // IV
+                    "CBC", // Mode
+                    "Raw", // Input
+                    "Hex" // Output
+                ]
+            }
+        ],
+    }
 ]);
--- a/tests/operations/tests/Float.mjs
+++ b/tests/operations/tests/Float.mjs
@ -0,0 +1,164 @@
+/**
+ * Float tests.
+ *
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ *
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+
+TestRegister.addTests([
+    {
+        name: "To Float: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            }
+        ],
+    },
+    {
+        name: "To Float (Big Endian, 4 bytes): 0.5",
+        input: "3f0000003f000000",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Little Endian, 4 bytes): 0.5",
+        input: "0000003f0000003f",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Little Endian", "Float (4 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Big Endian, 8 bytes): 0.5",
+        input: "3fe00000000000003fe0000000000000",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Big Endian", "Double (8 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "To Float (Little Endian, 8 bytes): 0.5",
+        input: "000000000000e03f000000000000e03f",
+        expectedOutput: "0.5 0.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["Auto"]
+            },
+            {
+                op: "To Float",
+                args: ["Little Endian", "Double (8 bytes)", "Space"]
+            }
+        ]
+    },
+    {
+        name: "From Float: nothing",
+        input: "",
+        expectedOutput: "",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Big Endian, 4 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "3f0000003f000000",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Little Endian, 4 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "0000003f0000003f",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Little Endian", "Float (4 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Big Endian, 8 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "3fe00000000000003fe0000000000000",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Big Endian", "Double (8 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    },
+    {
+        name: "From Float (Little Endian, 8 bytes): 0.5",
+        input: "0.5 0.5",
+        expectedOutput: "000000000000e03f000000000000e03f",
+        recipeConfig: [
+            {
+                op: "From Float",
+                args: ["Little Endian", "Double (8 bytes)", "Space"]
+            },
+            {
+                op: "To Hex",
+                args: ["None"]
+            }
+        ]
+    }
+]);
--- a/tests/operations/tests/XXTEA.mjs
+++ b/tests/operations/tests/XXTEA.mjs
@ -0,0 +1,62 @@
+/**
+ * Base64 tests.
+ *
+ * @author devcydo [devcydo@gmail.com]
+ *
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "XXTEA",
+        input: "Hello World! 你好，中国！",
+        expectedOutput: "QncB1C0rHQoZ1eRiPM4dsZtRi9pNrp7sqvX76cFXvrrIHXL6",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "ნუ პანიკას",
+        expectedOutput: "PbWjnbFmP8Apu2MKOGNbjeW/72IZLlLMS/g82ozLxwE=",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "ნუ პანიკას",
+        expectedOutput: "dHrOJ4ClIx6gH33NPSafYR2GG7UqsazY6Xfb0iekBY4=",
+        reecipeConfig: [
+            {
+                args: "ll3kj209d2"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "",
+        expectedOutput: "Invalid input length (0)",
+        reecipeConfig: [
+            {
+                args: "1234567890"
+            },
+        ],
+    },
+    {
+        name: "XXTEA",
+        input: "",
+        expectedOutput: "Invalid input length (0)",
+        reecipeConfig: [
+            {
+                args: ""
+            },
+        ],
+    },
+]);