cyberchef 11.1.0 → 11.3.0

package/src/core/operations/AsconDecrypt.mjs

@@ -0,0 +1,112 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import JsAscon from "js-ascon";
+
+/**
+ * Ascon Decrypt operation
+ */
+class AsconDecrypt extends Operation {
+
+    /**
+     * AsconDecrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Ascon Decrypt";
+        this.module = "Ciphers";
+        this.description = "Ascon-AEAD128 authenticated decryption as standardised in NIST SP 800-232. Decrypts ciphertext and verifies the authentication tag. Decryption will fail if the ciphertext or associated data has been tampered with.<br><br><b>Key:</b> Must be exactly 16 bytes (128 bits).<br><br><b>Nonce:</b> Must be exactly 16 bytes (128 bits). Must match the nonce used during encryption.<br><br><b>Associated Data:</b> Must match the associated data used during encryption. Any mismatch will cause authentication failure.";
+        this.infoURL = "https://wikipedia.org/wiki/Ascon_(cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Nonce",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Associated Data",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": ["Hex", "Raw"]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     * @throws {OperationError} if invalid key or nonce length, or authentication fails
+     */
+    run(input, args) {
+        const key = Utils.convertToByteArray(args[0].string, args[0].option),
+            nonce = Utils.convertToByteArray(args[1].string, args[1].option),
+            ad = Utils.convertToByteArray(args[2].string, args[2].option),
+            inputType = args[3],
+            outputType = args[4];
+
+        if (key.length !== 16) {
+            throw new OperationError(`Invalid key length: ${key.length} bytes.
+
+Ascon-AEAD128 requires a key of exactly 16 bytes (128 bits).`);
+        }
+
+        if (nonce.length !== 16) {
+            throw new OperationError(`Invalid nonce length: ${nonce.length} bytes.
+
+Ascon-AEAD128 requires a nonce of exactly 16 bytes (128 bits).`);
+        }
+
+        // Convert input to byte array
+        const inputData = Utils.convertToByteArray(input, inputType);
+
+        const keyUint8 = new Uint8Array(key);
+        const nonceUint8 = new Uint8Array(nonce);
+        const adUint8 = new Uint8Array(ad);
+        const ciphertextUint8 = new Uint8Array(inputData);
+
+        try {
+            // Decrypt (returns Uint8Array containing plaintext)
+            const plaintext = JsAscon.decrypt(keyUint8, nonceUint8, adUint8, ciphertextUint8);
+
+            // Return in requested format
+            if (outputType === "Hex") {
+                return toHexFast(plaintext);
+            } else {
+                return Utils.arrayBufferToStr(Uint8Array.from(plaintext).buffer);
+            }
+        } catch (e) {
+            throw new OperationError("Unable to decrypt: authentication failed. The ciphertext, key, nonce, or associated data may be incorrect or tampered with.");
+        }
+    }
+
+}
+
+export default AsconDecrypt;

package/src/core/operations/AsconEncrypt.mjs

@@ -0,0 +1,108 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import JsAscon from "js-ascon";
+
+/**
+ * Ascon Encrypt operation
+ */
+class AsconEncrypt extends Operation {
+
+    /**
+     * AsconEncrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Ascon Encrypt";
+        this.module = "Ciphers";
+        this.description = "Ascon-AEAD128 authenticated encryption as standardised in NIST SP 800-232. Ascon is a family of lightweight authenticated encryption algorithms designed for constrained devices such as IoT sensors and embedded systems.<br><br><b>Key:</b> Must be exactly 16 bytes (128 bits).<br><br><b>Nonce:</b> Must be exactly 16 bytes (128 bits). Should be unique for each encryption with the same key. Never reuse a nonce with the same key.<br><br><b>Associated Data:</b> Optional additional data that is authenticated but not encrypted. Useful for including metadata like headers or timestamps.<br><br>The output includes both the ciphertext and a 128-bit authentication tag.";
+        this.infoURL = "https://wikipedia.org/wiki/Ascon_(cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Nonce",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Associated Data",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Hex", "Raw"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     * @throws {OperationError} if invalid key or nonce length
+     */
+    run(input, args) {
+        const key = Utils.convertToByteArray(args[0].string, args[0].option),
+            nonce = Utils.convertToByteArray(args[1].string, args[1].option),
+            ad = Utils.convertToByteArray(args[2].string, args[2].option),
+            inputType = args[3],
+            outputType = args[4];
+
+        if (key.length !== 16) {
+            throw new OperationError(`Invalid key length: ${key.length} bytes.
+
+Ascon-AEAD128 requires a key of exactly 16 bytes (128 bits).`);
+        }
+
+        if (nonce.length !== 16) {
+            throw new OperationError(`Invalid nonce length: ${nonce.length} bytes.
+
+Ascon-AEAD128 requires a nonce of exactly 16 bytes (128 bits).`);
+        }
+
+        // Convert input to byte array
+        const inputData = Utils.convertToByteArray(input, inputType);
+
+        const keyUint8 = new Uint8Array(key);
+        const nonceUint8 = new Uint8Array(nonce);
+        const adUint8 = new Uint8Array(ad);
+        const inputUint8 = new Uint8Array(inputData);
+
+        // Encrypt (returns Uint8Array containing ciphertext + tag)
+        const ciphertext = JsAscon.encrypt(keyUint8, nonceUint8, adUint8, inputUint8);
+
+        // Return in requested format
+        if (outputType === "Hex") {
+            return toHexFast(ciphertext);
+        } else {
+            return Utils.arrayBufferToStr(Uint8Array.from(ciphertext).buffer);
+        }
+    }
+
+}
+
+export default AsconEncrypt;

package/src/core/operations/AsconHash.mjs

@@ -0,0 +1,49 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import JsAscon from "js-ascon";
+
+/**
+ * Ascon Hash operation
+ */
+class AsconHash extends Operation {
+
+    /**
+     * AsconHash constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Ascon Hash";
+        this.module = "Crypto";
+        this.description = "Ascon-Hash256 produces a fixed 256-bit (32-byte) cryptographic hash as standardised in NIST SP 800-232. Ascon is a family of lightweight authenticated encryption and hashing algorithms designed for constrained devices such as IoT sensors and embedded systems.<br><br>The algorithm was selected by NIST in 2023 as the new standard for lightweight cryptography after a multi-year competition.";
+        this.infoURL = "https://wikipedia.org/wiki/Ascon_(cipher)";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+
+        const inputUint8 = new Uint8Array(input);
+
+        // Compute hash (returns Uint8Array)
+        const hashResult = JsAscon.hash(inputUint8);
+
+        // Convert to hex string
+        return toHexFast(hashResult);
+    }
+
+}
+
+export default AsconHash;

package/src/core/operations/AsconMAC.mjs

@@ -0,0 +1,68 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import AsconMac from "../vendor/ascon.mjs";
+
+/**
+ * Ascon MAC operation
+ */
+class AsconMAC extends Operation {
+
+    /**
+     * AsconMAC constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Ascon MAC";
+        this.module = "Crypto";
+        this.description = "Ascon-Mac produces a 128-bit (16-byte) message authentication code as part of the Ascon family standardised by NIST in SP 800-232. It provides authentication for messages using a secret key, ensuring both data integrity and authenticity.<br><br>Ascon is designed for lightweight cryptography on constrained devices such as IoT sensors and embedded systems.";
+        this.infoURL = "https://wikipedia.org/wiki/Ascon_(cipher)";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            }
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {string}
+     * @throws {OperationError} if invalid key length
+     */
+    run(input, args) {
+        const keyArray = Utils.convertToByteArray(args[0].string, args[0].option);
+
+        if (keyArray.length !== 16) {
+            throw new OperationError(`Invalid key length: ${keyArray.length} bytes.
+
+Ascon-Mac requires a key of exactly 16 bytes (128 bits).`);
+        }
+
+        // Convert to Uint8Array for vendor Ascon implementation
+        const keyUint8 = new Uint8Array(keyArray);
+        const inputUint8 = new Uint8Array(input);
+
+        // Compute MAC (returns Uint8Array)
+        const macResult = AsconMac.mac(keyUint8, inputUint8);
+
+        // Convert to hex string
+        return toHexFast(macResult);
+    }
+
+}
+
+export default AsconMAC;

package/src/core/operations/AutomatedValidationTestOp.mjs

@@ -0,0 +1,84 @@
+/**
+ * @author CyberChef
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Automated validation test operation
+ */
+class AutomatedValidationTestOp extends Operation {
+
+    /**
+     * AutomatedValidationTestOp constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Automated Validation Test Op";
+        this.module = "Default";
+        this.description = "Operation used specifically to test automated parameter validation.";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Integer Number",
+                "type": "number",
+                "value": 5,
+                "min": 5,
+                "max": 10,
+                "integer": true
+            },
+            {
+                "name": "Real Number",
+                "type": "number",
+                "value": 1.5,
+                "min": 1.5,
+                "max": 5.5
+            },
+            {
+                "name": "Non Empty String",
+                "type": "string",
+                "value": "hello",
+                "maxLength": 5,
+                "allowEmpty": false
+            },
+            {
+                "name": "Empty Allowed String",
+                "type": "string",
+                "value": "",
+                "allowEmpty": true
+            },
+            {
+                "name": "Non Empty Toggle String",
+                "type": "toggleString",
+                "value": {
+                    "option": "Option A",
+                    "string": "test"
+                },
+                "toggleValues": ["Option A", "Option B"],
+                "allowEmpty": false
+            },
+            {
+                "name": "Option Ingredient",
+                "type": "option",
+                "value": ["[Group 1]", "Option 1", "Option 2", "[/Group 1]", "[Group 2]", "Option 3", "[/Group 2]"],
+                "allowEmpty": false
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        return "Success";
+    }
+
+}
+
+export default AutomatedValidationTestOp;

package/src/core/operations/AvroToJSON.mjs

@@ -39,7 +39,7 @@ class AvroToJSON extends Operation {
      * @param {Object[]} args
      * @returns {string}
      */
-    run(input, args) {
+    async run(input, args) {
         if (input.byteLength <= 0) {
             throw new OperationError("Please provide an input.");
         }

package/src/core/operations/BLAKE3.mjs

@@ -30,7 +30,11 @@ class BLAKE3 extends Operation {
         this.args = [
             {
                 "name": "Size (bytes)",
-                "type": "number"
+                "type": "number",
+                "value": 16,
+                "min": 1,
+                "max": 65535, // arbitrary limit to prevent resource exhaustion
+                "integer": true,
             }, {
                 "name": "Key",
                 "type": "string",

package/src/core/operations/BcryptCompare.mjs

@@ -5,6 +5,7 @@
  */
 
 import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
 import bcrypt from "bcryptjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
 
@@ -43,11 +44,16 @@ class BcryptCompare extends Operation {
     async run(input, args) {
         const hash = args[0];
 
-        const match = await bcrypt.compare(input, hash, undefined, p => {
-            // Progress callback
-            if (isWorkerEnvironment())
-                self.sendStatusMessage(`Progress: ${(p * 100).toFixed(0)}%`);
-        });
+        let match;
+        try {
+            match = await bcrypt.compare(input, hash, undefined, p => {
+                // Progress callback
+                if (isWorkerEnvironment())
+                    self.sendStatusMessage(`Progress: ${(p * 100).toFixed(0)}%`);
+            });
+        } catch (err) {
+            throw new OperationError(err.toString());
+        }
 
         return match ? "Match: " + input : "No match";
 

package/src/core/operations/BitShiftLeft.mjs

@@ -27,7 +27,10 @@ class BitShiftLeft extends Operation {
             {
                 "name": "Amount",
                 "type": "number",
-                "value": 1
+                "value": 1,
+                "min": 0,
+                "max": 7,
+                "integer": true,
             }
         ];
     }

package/src/core/operations/Bzip2Compress.mjs

@@ -47,7 +47,7 @@ class Bzip2Compress extends Operation {
      * @param {Object[]} args
      * @returns {File}
      */
-    run(input, args) {
+    async run(input, args) {
         const [blockSize, workFactor] = args;
         if (input.byteLength <= 0) {
             throw new OperationError("Please provide an input.");

package/src/core/operations/DechunkHTTPResponse.mjs

@@ -45,12 +45,15 @@ class DechunkHTTPResponse extends Operation {
         const lineEndingsLength = lineEndings.length;
         let chunkSize = parseInt(input.slice(0, chunkSizeEnd), 16);
         while (!isNaN(chunkSize)) {
+            if (chunkSize === 0) {
+                break;
+            }
             chunks.push(input.slice(chunkSizeEnd, chunkSize + chunkSizeEnd));
             input = input.slice(chunkSizeEnd + chunkSize + lineEndingsLength);
             chunkSizeEnd = input.indexOf(lineEndings) + lineEndingsLength;
             chunkSize = parseInt(input.slice(0, chunkSizeEnd), 16);
         }
-        return chunks.join("") + input;
+        return chunks.join("");
     }
 
 }

package/src/core/operations/ExtendedGCD.mjs

@@ -0,0 +1,101 @@
+/**
+ * @author p-leriche [philip.leriche@cantab.net]
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { parseBigInt, egcd } from "../lib/BigIntUtils.mjs";
+
+/* ---------- operation class ---------- */
+
+/**
+ * Extended GCD operation
+ */
+class ExtendedGCD extends Operation {
+    /**
+     * ExtendedGCD constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Extended GCD";
+        this.module = "Crypto";
+        this.description =
+            "Computes the Extended Euclidean Algorithm for integers <i>a</i> and <i>b</i>.<br><br>" +
+            "Finds integers <i>x</i> and <i>y</i> (Bezout coefficients) such that:<br>" +
+            "a*x + b*y = gcd(a, b)<br><br>" +
+            "This is fundamental to many number theory algorithms including modular inverse, " +
+            "solving linear Diophantine equations, and cryptographic operations.<br><br>" +
+            "<b>Input handling:</b> If either <i>a</i> or <i>b</i> is left blank, " +
+            "its value is taken from the Input field.";
+        this.infoURL = "https://wikipedia.org/wiki/Extended_Euclidean_algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Value a",
+                type: "string",
+                value: ""
+            },
+            {
+                name: "Value b",
+                type: "string",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [aStr, bStr] = args;
+
+        // Trim everything so "" and "   " count as empty
+        const aParam = aStr?.trim();
+        const bParam = bStr?.trim();
+        const inputVal = input?.trim();
+
+        let a, b;
+
+        if (aParam && bParam) {
+            // Case 1: both values given as parameters
+            a = aParam;
+            b = bParam;
+        } else if (!aParam && bParam) {
+            // Case 2: a missing - take from input
+            a = inputVal;
+            b = bParam;
+            if (!a) throw new OperationError("Value a must be defined");
+        } else if (aParam && !bParam) {
+            // Case 3: b missing - take from input
+            a = aParam;
+            b = inputVal;
+            if (!b) throw new OperationError("Value b must be defined");
+        } else if (!aParam && !bParam) {
+            // Case 4: both values missing
+            throw new OperationError("Values a and b must be defined");
+        }
+
+        const aBI = parseBigInt(a, "Value a");
+        const bBI = parseBigInt(b, "Value b");
+
+        const [g, x, y] = egcd(aBI, bBI);
+        const gcd = g < 0n ? -g : g;
+
+        // Format output string bearing in mind that crypto-grade numbers
+        // may greatly exceed the line length.
+        let output = "gcd: " + gcd.toString() + "\n\n";
+        output += "Bezout coefficients:\n";
+        output += "x = " + x.toString() + "\n";
+        output += "y = " + y.toString() + "\n\n";
+
+        return output;
+    }
+}
+
+export default ExtendedGCD;

package/src/core/operations/FromBase.mjs

@@ -51,9 +51,10 @@ class FromBase extends Operation {
         if (number.length === 1) return result;
 
         // Fractional part
+        const radixBN = new BigNumber(radix);
         for (let i = 0; i < number[1].length; i++) {
             const digit = new BigNumber(number[1][i], radix);
-            result += digit.div(Math.pow(radix, i+1));
+            result = result.plus(digit.div(radixBN.pow(i + 1)));
         }
 
         return result;

package/src/core/operations/FromCOBS.mjs

@@ -0,0 +1,38 @@
+/**
+ * @author Imantas Lukenskas [imantas@lukenskas.dev]
+ * @copyright Imantas Lukenskas 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {fromCobs} from "../lib/COBS.mjs";
+
+/**
+ * From COBS operation
+ */
+class FromCOBS extends Operation {
+    /**
+     * FromCOBS constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From COBS";
+        this.module = "Default";
+        this.description = "Decodes COBS encoded bytes";
+        this.infoURL = "https://wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        return fromCobs(input);
+    }
+}
+
+export default FromCOBS;