10.14.0

Previously, an array type error prevented any output when selecting
the 'Raw' output option for the ChaCha operation. This did not
show up in tests, as they all compared to hex values.

This also adds a test (relying on the 'To Hex' operation) that
catches this.

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

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",

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",

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"
         ]
     },

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);

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);

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);
         }
     }
 

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;

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;

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;

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;

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.
     

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);
     }),

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";

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",

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
+                ]
+            }
+        ],
+    }
 ]);

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"]
+            }
+        ]
+    }
+]);

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: ""
+            },
+        ],
+    },
+]);