cyberchef 10.22.0 → 10.23.0

package/src/web/stylesheets/layout/_banner.css

@@ -26,6 +26,36 @@
     color: var(--banner-url-colour);
 }
 
+#options:focus {
+    background-color: #eef3ec;
+    border: solid black 2px;
+    border-radius: 4px;
+}
+
+#support:focus {
+    background-color: #eef3ec;
+    border: solid black 2px;
+    border-radius: 4px;
+}
+
+#notice:focus {
+    background-color: #eef3ec;
+    border: solid black 2px;
+    border-radius: 4px;
+}
+
+#banner .col a:focus {
+    background-color: #eef3ec;
+    border: solid black 2px;
+    border-radius: 4px;
+}
+
+#notice-wrapper #notice:focus {
+    background-color: #eef3ec;
+    border: solid black 2px;
+    border-radius: 4px;
+}
+
 #notice-wrapper {
     text-align: center;
     overflow: hidden;

package/src/web/stylesheets/layout/_modals.css

@@ -78,6 +78,11 @@
     border-left: 2px solid var(--primary-border-colour);
 }
 
+p a:focus {
+    color: #0a6ebd;
+    text-decoration: underline;
+}
+
 .checkbox label input[type=checkbox]+.checkbox-decorator .check,
 .checkbox label input[type=checkbox]+.checkbox-decorator .check::before {
     border-color: var(--input-border-colour);

package/src/web/stylesheets/utils/_overrides.css

@@ -249,6 +249,13 @@ optgroup {
 }
 
 
+/* Bootstrap form inside CodeMirror editor */
+
+.cm-panel > .bmd-form-group {
+    padding-top: 0;
+}
+
+
 /* CodeMirror */
 
 .ͼ2 .cm-specialChar,

package/src/web/waiters/ControlsWaiter.mjs

@@ -57,6 +57,18 @@ class ControlsWaiter {
         }
     }
 
+    /**
+     * Checks or unchecks the Auto Bake checkbox with "Enter"
+     * @param {Event} ev
+     */
+    autoBakeKeyboardHandler(ev) {
+        const checkBox = document.getElementById("auto-bake");
+        ev.preventDefault();
+        if (ev.key === "Enter" || ev.key === " ") {
+            checkBox.checked = !checkBox.checked;
+        }
+    }
+
 
     /**
      * Handler to trigger baking.
@@ -387,6 +399,18 @@ class ControlsWaiter {
      */
     supportButtonClick(e) {
         e.preventDefault();
+        const faqs = document.getElementById("faqs");
+        const faqsAElement = faqs.getElementsByTagName("a");
+        for (let i = 0; i < faqsAElement.length; i++) {
+            faqsAElement[i].setAttribute("tabindex", "0");
+            faqsAElement[i].addEventListener("keydown", this.navigateFAQList, false);
+        }
+
+        const tabs = document.querySelectorAll('[role="tab"]');
+
+        for (let i = 0; i < tabs.length; i++) {
+            tabs[i].addEventListener("keydown", this.changeTabs, false);
+        }
 
         const reportBugInfo = document.getElementById("report-bug-info");
         const saveLink = this.generateStateUrl(true, true, null, null, "https://gchq.github.io/CyberChef/");
@@ -403,6 +427,64 @@ ${navigator.userAgent}
     }
 
 
+    /**
+    * @param {Event} ev
+    */
+    changeTabs(ev) {
+        const tab = ev.target;
+        ev.preventDefault();
+        ev.stopPropagation();
+
+        if (ev.key === "ArrowRight") {
+            const nextTab = tab.parentElement;
+            if (nextTab.nextElementSibling === null) {
+                tab.parentElement.parentElement.firstElementChild.firstElementChild.focus();
+            } else {
+                nextTab.nextElementSibling.firstElementChild.focus();
+            }
+
+        } else if (ev.key === "ArrowLeft") {
+            const prevTab = tab.parentElement;
+
+            if (prevTab.previousElementSibling === null) {
+                tab.parentElement.parentElement.lastElementChild.firstElementChild.focus();
+            } else {
+                prevTab.previousElementSibling.firstElementChild.focus();
+            }
+        } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-1")) {
+            document.getElementById("faqs").querySelector("[class='btn btn-primary']").focus();
+        } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-2")) {
+            document.getElementById("report-bug").querySelector("[class='btn btn-primary']").focus();
+        } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-3")) {
+            document.getElementById("about").querySelector("[href]").focus();
+        } else if (ev.key === "Tab" && !ev.shiftKey && ev.target === document.getElementById("tab-4")) {
+            const button = document.getElementById("support-modal").getElementsByClassName("modal-footer");
+            const close = button[0].firstElementChild;
+            close.focus();
+        } else if (ev.key === "Enter" || ev.key === "Space" || ev.key === " ") {
+            tab.click();
+        }
+    }
+
+    /**
+   * @param {Event} ev
+   */
+    navigateFAQList(ev) {
+
+        const el = ev.target.nextElementSibling;
+        if (ev.key === "Enter" || ev.key === "Space" || ev.key === " ") {
+            ev.preventDefault();
+            const question = el.classList;
+            if (question !== undefined && question.value) {
+                if (!question.value.includes("show")) {
+                    question.add("show");
+                } else if (question.contains("show")) {
+                    question.remove("show");
+                }
+            }
+        }
+    }
+
     /**
      * Shows the stale indicator to show that the input or recipe has changed
      * since the last bake.

package/src/web/waiters/InputWaiter.mjs

@@ -153,16 +153,22 @@ class InputWaiter {
                     paste(event, view) {
                         const clipboardData = event.clipboardData;
                         const items = clipboardData.items;
-                        const files = [];
+                        let files = [];
                         for (let i = 0; i < items.length; i++) {
                             const item = items[i];
-                            if (item.kind === "file") {
-                                const file = item.getAsFile();
-                                files.push(file);
-
-                                event.preventDefault(); // Prevent the default paste behavior
+                            if (item.kind === "string") {
+                                // If there are any string items they should be preferred over
+                                // files.
+                                files = [];
+                                break;
+                            } else if (item.kind === "file") {
+                                files.push(item.getAsFile());
                             }
                         }
+                        if (files.length > 0) {
+                            // Prevent the default paste behavior, afterPaste will load the files instead
+                            event.preventDefault();
+                        }
                         setTimeout(() => {
                             self.afterPaste(files);
                         });

package/src/web/waiters/RecipeWaiter.mjs

@@ -417,6 +417,8 @@ class RecipeWaiter {
             el.classList.add("flow-control-op");
         }
 
+        $(el).find("[data-toggle='tooltip']").tooltip();
+
         // Disable auto-bake if this is a manual op
         if (op.manualBake && this.app.autoBake_) {
             this.manager.controls.setAutoBake(false);
@@ -442,8 +444,6 @@ class RecipeWaiter {
         this.buildRecipeOperation(item);
         document.getElementById("rec-list").appendChild(item);
 
-        $(item).find("[data-toggle='tooltip']").tooltip();
-
         item.dispatchEvent(this.manager.operationadd);
         return item;
     }

package/tests/browser/02_ops.js

@@ -34,7 +34,14 @@ module.exports = {
         testOp(browser, "AES Encrypt", "test input", "e42eb8fbfb7a98fff061cd2c1a794d92", [{"option": "Hex", "string": "00112233445566778899aabbccddeeff"}, {"option": "Hex", "string": "00000000000000000000000000000000"}, "CBC", "Raw", "Hex"]);
         testOp(browser, "AND", "test input", "4$04  $044", [{ "option": "Hex", "string": "34" }]);
         testOp(browser, "Add line numbers", "test input", "1 test input");
-        testOp(browser, ["From Hex", "Add Text To Image", "To Base64"], Images.PNG_HEX, Images.PNG_CHEF_B64, [[], ["Chef", "Center", "Middle", 0, 0, 16], []]);
+        testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "50cdf8ea483c55564a091650c2bccb4586f919b721e5fe9d6a61660505b4346d6ebdb2ef0cf075a7728cd84cb26ea3e477b5bd86a94a49a27d79423994afb60a", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto"], []]);
+        testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "78b3055463d9167dd039e47f451acaf06c593d209f8e405b4e18011cdcf190dc0af5952be887d93c0ebd38738e978120c1294c71104e6b00d3f9de8d6320ec1c", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Black"], []]);
+        testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "4ab4d4b6cb22ad700f6cd144c2c8ecad2a094f21a1d1d5d48eb6c8f97417192f89b4512f6a78276d49668ebef5e89c3a4d14860cb79399a0dafce98c92209e07", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Mono"], []]);
+        testOp(browser, ["From Hex", "Add Text To Image", "SHA2"], Images.PNG_HEX, "11490db4907516b4d9e256da1ac0b02b561fa7547971e6316a8a0b90c9c66585a11f3145672c6d972b1a221d3bfad9c8a97de7ff77fd9442ebc40f39c1ef9ef7", [[], ["Chef", "Center", "Middle", 0, 0, 16, "Roboto Slab"], []]);
+        testOp(browser, ["From Hex", "Dither Image", "SHA2"], Images.PNG_HEX, "cbf587a78915cfb14546ba83080b13e5054800802488dd0cb786b8951e7dc0b48f055260917bd0ccfc075e422b9d6aff112948562653995d74e70f0b66367ac3", [[], [], []]);
+        testOp(browser, ["From Hex", "Generate Image", "SHA2"], Images.PNG_HEX, "2c451762a6c9192fd31dc80765eab3f447be70ea51f6fdb6911ade4d89d4a98bd0a1ff00b08d76aac472faeceb54b66092e3f3be7bbf899bf3e55ca9c96a56aa", [[], [], []]);
+        testOp(browser, ["From Hex", "Image Hue/Saturation/Lightness", "SHA2"], Images.PNG_HEX, "522dfc0bbef00e05c5d6861a002039fa2952e4bbb7fe8d21d0d538ef6f9d65da82065929b4150dc5b8b49460ee6c9bef7f660b86f8d4e7442a07c61c0a152a4b", [[], [50, 50, 50], []]);
+        testOp(browser, ["From Hex", "Resize Image", "SHA2"], Images.PNG_HEX, "654bfbf0a0537c901459c4bc22c5fb0bacbf01af775a0733e3a1c46cda5b699bcc4ed85322d813c7bb9b245d62d64425c0766fe03d3d20bc63634e2a4df17626", [[], [64, 64], []]);
         testOp(browser, "Adler-32 Checksum", "test input", "16160411");
         testOp(browser, "Affine Cipher Decode", "test input", "rcqr glnsr", [1, 2]);
         testOp(browser, "Affine Cipher Encode", "test input", "gndg zoujg", [3, 1]);
@@ -43,6 +50,14 @@ module.exports = {
         testOp(browser, "Analyse hash", "0123456789abcdef", /CRC-64/);
         testOp(browser, "Atbash Cipher", "test input", "gvhg rmkfg");
         // testOp(browser, "Avro to JSON", "test input", "test_output");
+        testOp(browser,
+            [
+                "From Hex", "Avro to JSON"
+            ],
+            "4f626a0104166176726f2e736368656d6196017b2274797065223a227265636f7264222c226e616d65223a22736d616c6c222c226669656c6473223a5b7b226e616d65223a226e616d65222c2274797065223a22737472696e67227d5d7d146176726f2e636f646563086e756c6c004e0247632e3702e5b75cdab9a62f1541020e0c6d796e616d654e0247632e3702e5b75cdab9a62f1541",
+            '{"name":"myname"}\n',
+            [[], [false]]
+        );
         testOp(browser, "BLAKE2b", "test input", "33ebdc8f38177f3f3f334eeb117a84e11f061bbca4db6b8923e5cec85103f59f415551a5d5a933fdb6305dc7bf84671c2540b463dbfa08ee1895cfaa5bd780b5", ["512", "Hex", { "option": "UTF8", "string": "pass" }]);
         testOp(browser, "BLAKE2s", "test input", "defe73d61dfa6e5807e4f9643e159a09ccda6be3c26dcd65f8a9bb38bfc973a7", ["256", "Hex", { "option": "UTF8", "string": "pass" }]);
         testOp(browser, "BSON deserialise", "\u0011\u0000\u0000\u0000\u0002a\u0000\u0005\u0000\u0000\u0000test\u0000\u0000", '{\u000A  "a": "test"\u000A}');
@@ -58,7 +73,10 @@ module.exports = {
         testOp(browser, "Bit shift right", "test input", ":29:\u0010478::");
         testOp(browser, "Blowfish Decrypt", "10884e15427dd84ec35204e9c8e921ae", "test_output", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Hex", "Raw"]);
         testOp(browser, "Blowfish Encrypt", "test input", "f0fadbd1d90d774f714248cf26b96410", [{"option": "Hex", "string": "1234567801234567"}, {"option": "Hex", "string": "0011223344556677"}, "CBC", "Raw", "Hex"]);
-        testOp(browser, ["From Hex", "Blur Image", "To Base64"], Images.PNG_HEX, Images.PNG_BLUR_B64);
+        testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "24f2e89f3e00cc35f551bbc48ea82e76474946ce0282183494d1ca3d3b0012c27b6102c4368ae056dc7fecb6df7886d86ff3d29b7e5965493f30c371eee9a24e");
+        testOp(browser, ["From Hex", "Blur Image", "SHA2"], Images.PNG_HEX, "2c49d89fc10c94352c9a19f82de353c37928831d6f976a6b36eb918825a0ba027980801838228a4a0da63f1886e4fa59b6666f992ad2d2b7d4622253dc034052", [[], [5, "Gaussian"], []]);
+        testOp(browser, ["From Hex", "Sharpen Image", "SHA2"], Images.PNG_HEX, "acc7027642c2eeb67d7356a80ed8a1bdce9adabf656ea1294e47723f506626a7aa41f1660fa844a1e1e83b17180017ab0d5bccd7f6a341692832020dc887eaa5");
+        testOp(browser, ["From Hex", "Contain Image", "SHA2"], Images.PNG_HEX, "cb871ad0722d487d56a2b18247b1aa30ecc244eb717e08e23a55cae78759553312dc1717196d7cb9daa04743e57c56fc3901ba92be5a68fb03c377f718e8efe7");
         testOpHtml(browser, "Bombe", "XTSYN WAEUG EZALY NRQIM AMLZX MFUOD AWXLY LZCUZ QOQBQ JLCPK NDDRW F", "table tr:last-child td:first-child", "ECG", ["3-rotor", "LEYJVCNIXWPBQMDRTAKZGFUHOS", "BDFHJLCPRTXVZNYEIWGAKMUSQO<W", "AJDKSIRUXBLHWTMCQGZNPYFVOE<F", "ESOVPZJAYQUIRHXLNFTGKDCMWB<K", "AY BR CU DH EQ FS GL IP JX KN MO TZ VW", "HELLO CYBER CHEFU SER", 0, true]);
         testOp(browser, ["Bzip2 Compress", "To Hex"], "test input", "42 5a 68 39 31 41 59 26 53 59 cf 96 82 1d 00 00 03 91 80 40 00 02 21 4e 00 20 00 21 90 c2 10 c0 88 33 92 8e df 17 72 45 38 50 90 cf 96 82 1d");
         testOp(browser, ["From Hex", "Bzip2 Decompress"], "425a68393141592653597b0884b7000003038000008200ce00200021a647a4218013709517c5dc914e14241ec2212dc0", "test_output", [[], [true]]);
@@ -196,6 +214,7 @@ module.exports = {
         testOpHtml(browser, "Index of Coincidence", "test input", "", /Index of Coincidence: 0.08333333333333333/);
         testOpImage(browser, "Invert Image", "files/Hitchhikers_Guide.jpeg");
     // testOp(browser, "JPath expression", "test input", "test_output");
+        testOp(browser, "Jq", '{"a":{"b":1}}', '{"b":1}', [".a"]);
         testOpHtml(browser, "JSON Beautify", "{a:1}", ".json-dict .json-literal", "1");
         // testOp(browser, "JSON Minify", "test input", "test_output");
     // testOp(browser, "JSON to CSV", "test input", "test_output");
@@ -249,7 +268,7 @@ module.exports = {
         testOpHtml(browser, "Parse colour code", "#000", ".colorpicker-preview", "rgb(0, 0, 0)");
         testOpHtml(browser, "Parse DateTime", "01/12/2000 13:00:00", "", /Date: Friday 1st December 2000/);
         // testOp(browser, "Parse IP range", "test input", "test_output");
-        testOpHtml(browser, "Parse IPv4 header", "45 c0 00 c4 02 89 00 00 ff 11　1e 8c c0 a8 0c 01 c0 a8 0c 02", "tr:last-child td:last-child", "192.168.12.2");
+        testOpHtml(browser, "Parse IPv4 header", "45 c0 00 c4 02 89 00 00 ff 11　1e 8c c0 a8 0c 01 c0 a8 0c 02", "tr:nth-last-child(2) td:last-child", "192.168.12.2");
         // testOp(browser, "Parse IPv6 address", "test input", "test_output");
     // testOp(browser, "Parse ObjectID timestamp", "test input", "test_output");
     // testOp(browser, "Parse QR Code", "test input", "test_output");
@@ -335,6 +354,7 @@ module.exports = {
         // testOp(browser, "Tail", "test input", "test_output");
         // testOp(browser, "Take bytes", "test input", "test_output");
         testOp(browser, "Tar", "test input", /^file\.txt\x00{92}/);
+        testOp(browser, "Template", "{\"one\": 1, \"two\": 2}", "1 2", ["{{ one }} {{ two }}"]);
         testOpHtml(browser, "Text Encoding Brute Force", "test input", "tr:nth-of-type(4) td:last-child", /t\u2400e\u2400s\u2400t\u2400/);
         // testOp(browser, "To BCD", "test input", "test_output");
         // testOp(browser, "To Base", "test input", "test_output");

package/tests/node/index.mjs

@@ -23,6 +23,7 @@ import "./tests/Dish.mjs";
 import "./tests/NodeDish.mjs";
 import "./tests/Utils.mjs";
 import "./tests/Categories.mjs";
+import "./tests/lib/BigIntUtils.mjs";
 
 const testStatus = {
     allTestsPassing: true,

package/tests/node/tests/lib/BigIntUtils.mjs

@@ -0,0 +1,150 @@
+import TestRegister from "../../../lib/TestRegister.mjs";
+import { parseBigInt, egcd, modPow } from "../../../../src/core/lib/BigIntUtils.mjs";
+import it from "../../assertionHandler.mjs";
+import assert from "assert";
+
+TestRegister.addApiTests([
+    // ===== parseBigInt tests =====
+    it("BigIntUtils: parseBigInt - decimal number", () => {
+        const value = parseBigInt("1", "test value");
+        assert.deepStrictEqual(value, BigInt("1"));
+    }),
+
+    it("BigIntUtils: parseBigInt - large decimal", () => {
+        const value = parseBigInt("123456789012345678901234567890", "test value");
+        assert.deepStrictEqual(value, BigInt("123456789012345678901234567890"));
+    }),
+
+    it("BigIntUtils: parseBigInt - hexadecimal lowercase", () => {
+        const value = parseBigInt("0xff", "test value");
+        assert.deepStrictEqual(value, BigInt("255"));
+    }),
+
+    it("BigIntUtils: parseBigInt - hexadecimal uppercase", () => {
+        const value = parseBigInt("0xFF", "test value");
+        assert.deepStrictEqual(value, BigInt("255"));
+    }),
+
+    it("BigIntUtils: parseBigInt - large hexadecimal", () => {
+        const value = parseBigInt("0x123456789ABCDEF", "test value");
+        assert.deepStrictEqual(value, BigInt("0x123456789ABCDEF"));
+    }),
+
+    it("BigIntUtils: parseBigInt - whitespace trimming", () => {
+        const value = parseBigInt("  42  ", "test value");
+        assert.deepStrictEqual(value, BigInt("42"));
+    }),
+
+    it("BigIntUtils: parseBigInt - invalid input (text)", () => {
+        assert.throws(() => parseBigInt("test", "test value"), {
+            name: "Error",
+            message: "test value must be decimal or hex (0x...)"
+        });
+    }),
+
+    it("BigIntUtils: parseBigInt - invalid input (hex without prefix)", () => {
+        assert.throws(() => parseBigInt("FF", "test value"), {
+            name: "Error",
+            message: "test value must be decimal or hex (0x...)"
+        });
+    }),
+
+    it("BigIntUtils: parseBigInt - invalid input (mixed)", () => {
+        assert.throws(() => parseBigInt("12abc", "test value"), {
+            name: "Error",
+            message: "test value must be decimal or hex (0x...)"
+        });
+    }),
+
+    // ===== egcd tests =====
+    it("BigIntUtils: egcd - basic coprime", () => {
+        const a = BigInt("36");
+        const b = BigInt("48");
+        const gcd = BigInt("12");
+        const bezout1 = BigInt("-1");
+        const bezout2 = BigInt("1");
+        assert.deepStrictEqual(egcd(a, b), [gcd, bezout1, bezout2]);
+    }),
+
+    it("BigIntUtils: egcd - coprime numbers", () => {
+        const [g, x, y] = egcd(BigInt("3"), BigInt("11"));
+        assert.strictEqual(g, BigInt("1"));
+        // Verify Bézout identity: a*x + b*y = gcd
+        assert.strictEqual(BigInt("3") * x + BigInt("11") * y, g);
+    }),
+
+    it("BigIntUtils: egcd - non-coprime numbers", () => {
+        const [g, x, y] = egcd(BigInt("240"), BigInt("46"));
+        assert.strictEqual(g, BigInt("2"));
+        // Verify Bézout identity
+        assert.strictEqual(BigInt("240") * x + BigInt("46") * y, g);
+    }),
+
+    it("BigIntUtils: egcd - with zero", () => {
+        const [g, x, y] = egcd(BigInt("17"), BigInt("0"));
+        assert.strictEqual(g, BigInt("17"));
+        assert.strictEqual(x, BigInt("1"));
+        assert.strictEqual(y, BigInt("0"));
+    }),
+
+    it("BigIntUtils: egcd - identical numbers", () => {
+        const [g, x, y] = egcd(BigInt("42"), BigInt("42"));
+        assert.strictEqual(g, BigInt("42"));
+        // Verify Bézout identity
+        assert.strictEqual(BigInt("42") * x + BigInt("42") * y, g);
+    }),
+
+    it("BigIntUtils: egcd - large numbers", () => {
+        const a = BigInt("123456789012345678901234567890");
+        const b = BigInt("987654321098765432109876543210");
+        const [g, x, y] = egcd(a, b);
+        // Verify Bézout identity
+        assert.strictEqual(a * x + b * y, g);
+    }),
+
+    // ===== modPow tests =====
+    it("BigIntUtils: modPow - basic", () => {
+        // 2^10 mod 1000 = 1024 mod 1000 = 24
+        const result = modPow(BigInt("2"), BigInt("10"), BigInt("1000"));
+        assert.strictEqual(result, BigInt("24"));
+    }),
+
+    it("BigIntUtils: modPow - RSA-like example", () => {
+        // Common RSA public exponent
+        const base = BigInt("123456789");
+        const exp = BigInt("65537");
+        const mod = BigInt("999999999999");
+        const result = modPow(base, exp, mod);
+        // Result should be less than modulus
+        assert(result < mod);
+        assert(result >= BigInt("0"));
+    }),
+
+    it("BigIntUtils: modPow - exponent zero", () => {
+        // Any number^0 = 1
+        const result = modPow(BigInt("999"), BigInt("0"), BigInt("100"));
+        assert.strictEqual(result, BigInt("1"));
+    }),
+
+    it("BigIntUtils: modPow - base zero", () => {
+        // 0^n = 0
+        const result = modPow(BigInt("0"), BigInt("5"), BigInt("100"));
+        assert.strictEqual(result, BigInt("0"));
+    }),
+
+    it("BigIntUtils: modPow - large exponent", () => {
+        // Test with very large exponent (efficient algorithm should handle this)
+        const result = modPow(BigInt("3"), BigInt("1000000"), BigInt("1000000007"));
+        assert(result >= BigInt("0"));
+        assert(result < BigInt("1000000007"));
+    }),
+
+    it("BigIntUtils: modPow - modular inverse verification", () => {
+        // If a*x . 1 (mod m), then modPow(a, 1, m) * x . 1 (mod m)
+        const a = BigInt("3");
+        const m = BigInt("11");
+        const x = BigInt("4"); // inverse of 3 mod 11
+        const result = modPow(a, BigInt("1"), m) * x % m;
+        assert.strictEqual(result, BigInt("1"));
+    }),
+]);

package/tests/node/tests/operations.mjs

@@ -867,13 +867,15 @@ pCGTErs=
     }),
 
     it("SQL Beautify", () => {
-        const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F
-FROM STATS;`);
-        const expected = `SELECT MONTH,
-         ID,
-         RAIN_I,
-         TEMP_F
-FROM STATS;`;
+        const result = chef.SQLBeautify(`SELECT MONTH, ID, RAIN_I, TEMP_F FROM STATS;`);
+        const expected =
+`SELECT
+  MONTH,
+  ID,
+  RAIN_I,
+  TEMP_F
+FROM
+  STATS;`;
         assert.strictEqual(result.toString(), expected);
     }),
 

package/tests/operations/index.mjs

@@ -14,6 +14,7 @@
 import { setLongTestFailure, logTestReport } from "../lib/utils.mjs";
 
 import TestRegister from "../lib/TestRegister.mjs";
+import "./tests/A1Z26CipherDecode.mjs";
 import "./tests/AESKeyWrap.mjs";
 import "./tests/AlternatingCaps.mjs";
 import "./tests/AvroToJSON.mjs";
@@ -61,10 +62,12 @@ import "./tests/Crypt.mjs";
 import "./tests/CSV.mjs";
 import "./tests/DateTime.mjs";
 import "./tests/DefangIP.mjs";
+import "./tests/DisassembleARM.mjs";
 import "./tests/DropNthBytes.mjs";
 import "./tests/ECDSA.mjs";
 import "./tests/ELFInfo.mjs";
 import "./tests/Enigma.mjs";
+import "./tests/ExtractAudioMetadata.mjs";
 import "./tests/ExtractEmailAddresses.mjs";
 import "./tests/ExtractHashes.mjs";
 import "./tests/ExtractIPAddresses.mjs";
@@ -76,6 +79,7 @@ import "./tests/FromDecimal.mjs";
 import "./tests/GenerateAllChecksums.mjs";
 import "./tests/GenerateAllHashes.mjs";
 import "./tests/GenerateDeBruijnSequence.mjs";
+import "./tests/GenerateQRCode.mjs";
 import "./tests/GetAllCasings.mjs";
 import "./tests/GOST.mjs";
 import "./tests/Gunzip.mjs";
@@ -118,6 +122,7 @@ import "./tests/NetBIOS.mjs";
 import "./tests/NormaliseUnicode.mjs";
 import "./tests/NTLM.mjs";
 import "./tests/OTP.mjs";
+import "./tests/ParseEthernetFrame.mjs";
 import "./tests/ParseIPRange.mjs";
 import "./tests/ParseObjectIDTimestamp.mjs";
 import "./tests/ParseQRCode.mjs";
@@ -151,7 +156,9 @@ import "./tests/Shuffle.mjs";
 import "./tests/SIGABA.mjs";
 import "./tests/SM2.mjs";
 import "./tests/SM4.mjs";
+import "./tests/RC6.mjs";
 // import "./tests/SplitColourChannels.mjs"; // Cannot test operations that use the File type yet
+import "./tests/SQLBeautify.mjs";
 import "./tests/StrUtils.mjs";
 import "./tests/StripIPv4Header.mjs";
 import "./tests/StripTCPHeader.mjs";
@@ -162,6 +169,7 @@ import "./tests/SymmetricDifference.mjs";
 import "./tests/TakeNthBytes.mjs";
 import "./tests/Template.mjs";
 import "./tests/TextEncodingBruteForce.mjs";
+import "./tests/TextIntegerConverter.mjs";
 import "./tests/ToFromInsensitiveRegex.mjs";
 import "./tests/TranslateDateTimeFormat.mjs";
 import "./tests/Typex.mjs";

package/tests/operations/tests/A1Z26CipherDecode.mjs

@@ -0,0 +1,33 @@
+/**
+ * A1Z26 Cipher Decode tests
+ *
+ * @author brick-pixel
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        "name": "A1Z26 Cipher Decode: basic decode",
+        "input": "8 5 12 12 15",
+        "expectedOutput": "hello",
+        "recipeConfig": [
+            {
+                "op": "A1Z26 Cipher Decode",
+                "args": ["Space"]
+            }
+        ]
+    },
+    {
+        "name": "A1Z26 Cipher Decode: empty input returns empty string",
+        "input": "",
+        "expectedOutput": "",
+        "recipeConfig": [
+            {
+                "op": "A1Z26 Cipher Decode",
+                "args": ["Space"]
+            }
+        ]
+    }
+]);