cyberchef 10.22.0 → 10.23.0

package/src/core/operations/ParseEthernetFrame.mjs

@@ -0,0 +1,112 @@
+/**
+ * @author tedk [tedk@ted.do]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import {fromHex, toHex} from "../lib/Hex.mjs";
+
+/**
+ * Parse Ethernet frame operation
+ */
+class ParseEthernetFrame extends Operation {
+
+    /**
+     * ParseEthernetFrame constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Parse Ethernet frame";
+        this.module = "Default";
+        this.description = "Parses an Ethernet frame and either shows the deduced values (Source and destination MAC, VLANs) or returns the packet data.<br /><br />Good for use in conjunction with the Parse IPv4, and Parse TCP/UDP recipes.";
+        this.infoURL = "https://en.wikipedia.org/wiki/Ethernet_frame#Frame_%E2%80%93_data_link_layer";
+        this.inputType = "string";
+        this.outputType = "html";
+        this.args = [
+            {
+                name: "Input type",
+                type: "option",
+                value: [
+                    "Raw", "Hex"
+                ],
+                defaultIndex: 0,
+            },
+            {
+                name: "Return type",
+                type: "option",
+                value: [
+                    "Text output", "Packet data", "Packet data (hex)",
+                ],
+                defaultIndex: 0,
+            }
+        ];
+    }
+
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {html}
+     */
+    run(input, args) {
+        const format = args[0];
+        const outputFormat = args[1];
+
+        if (format === "Hex") {
+            input = fromHex(input);
+        } else if (format === "Raw") {
+            input = new Uint8Array(Utils.strToArrayBuffer(input));
+        } else {
+            throw new OperationError("Invalid input format selected.");
+        }
+
+        const destinationMac = input.slice(0, 6);
+        const sourceMac = input.slice(6, 12);
+
+        let offset = 12;
+        const vlans = [];
+
+        while (offset < input.length) {
+            const ethType = Utils.byteArrayToChars(input.slice(offset, offset+2));
+            offset += 2;
+
+            if (ethType === "\x81\x00" || ethType === "\x88\xA8") {
+                // Parse the VLAN tag:
+                // [0000] 0000 0000 0000
+                //  ^^^ PRIO  - Ignored
+                //     ^ DEI  - Ignored
+                //        ^^^^ ^^^^ ^^^^ VLAN ID
+                const vlanTag = input.slice(offset, offset+2);
+                vlans.push(((vlanTag[0] & 0b00001111) << 8) | vlanTag[1]);
+
+                offset += 2;
+            } else {
+                break;
+            }
+        }
+
+        const packetData = input.slice(offset);
+
+        if (outputFormat === "Packet data") {
+            return Utils.byteArrayToChars(packetData);
+        } else if (outputFormat === "Packet data (hex)") {
+            return toHex(packetData);
+        } else if (outputFormat === "Text output") {
+            let retval = `Source MAC: ${toHex(sourceMac, ":")}\nDestination MAC: ${toHex(destinationMac, ":")}\n`;
+            if (vlans.length > 0) {
+                retval += `VLAN: ${vlans.join(", ")}\n`;
+            }
+            retval += `Data:\n${toHex(packetData)}`;
+            return retval;
+        }
+
+    }
+
+
+}
+
+export default ParseEthernetFrame;

package/src/core/operations/ParseIPv4Header.mjs

@@ -33,6 +33,12 @@ class ParseIPv4Header extends Operation {
                 "name": "Input format",
                 "type": "option",
                 "value": ["Hex", "Raw"]
+            },
+            {
+                "name": "Output format",
+                "type": "option",
+                "value": ["Table", "Data (hex)", "Data (raw)"],
+                defaultIndex: 0,
             }
         ];
     }
@@ -44,6 +50,8 @@ class ParseIPv4Header extends Operation {
      */
     run(input, args) {
         const format = args[0];
+        const outputFormat = args[1];
+
         let output;
 
         if (format === "Hex") {
@@ -98,7 +106,10 @@ class ParseIPv4Header extends Operation {
             checksumResult = givenChecksum + " (incorrect, should be " + correctChecksum + ")";
         }
 
-        output = `<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>Field</th><th>Value</th></tr>
+        const data = input.slice(ihl * 4);
+
+        if (outputFormat === "Table") {
+            output = `<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>Field</th><th>Value</th></tr>
 <tr><td>Version</td><td>${version}</td></tr>
 <tr><td>Internet Header Length (IHL)</td><td>${ihl} (${ihl * 4} bytes)</td></tr>
 <tr><td>Differentiated Services Code Point (DSCP)</td><td>${dscp}</td></tr>
@@ -116,13 +127,19 @@ class ParseIPv4Header extends Operation {
 <tr><td>Protocol</td><td>${protocol}, ${protocolInfo.protocol} (${protocolInfo.keyword})</td></tr>
 <tr><td>Header checksum</td><td>${checksumResult}</td></tr>
 <tr><td>Source IP address</td><td>${ipv4ToStr(srcIP)}</td></tr>
-<tr><td>Destination IP address</td><td>${ipv4ToStr(dstIP)}</td></tr>`;
+<tr><td>Destination IP address</td><td>${ipv4ToStr(dstIP)}</td></tr>
+<tr><td>Data (hex)</td><td>${toHex(data)}</td></tr>`;
 
-        if (ihl > 5) {
-            output += `<tr><td>Options</td><td>${toHex(options)}</td></tr>`;
-        }
+            if (ihl > 5) {
+                output += `<tr><td>Options</td><td>${toHex(options)}</td></tr>`;
+            }
 
-        return output + "</table>";
+            return output + "</table>";
+        } else if (outputFormat === "Data (hex)") {
+            return toHex(data);
+        } else if (outputFormat === "Data (raw)") {
+            return Utils.byteArrayToChars(data);
+        }
     }
 
 }

package/src/core/operations/ParseQRCode.mjs

@@ -13,7 +13,6 @@ import { parseQrCode } from "../lib/QRCode.mjs";
  * Parse QR Code operation
  */
 class ParseQRCode extends Operation {
-
     /**
      * ParseQRCode constructor
      */
@@ -22,24 +21,26 @@ class ParseQRCode extends Operation {
 
         this.name = "Parse QR Code";
         this.module = "Image";
-        this.description = "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.<br><br><u>Normalise Image</u><br>Attempts to normalise the image before parsing it to improve detection of a QR code.";
+        this.description =
+            "Reads an image file and attempts to detect and read a Quick Response (QR) code from the image.<br><br><u>Normalise Image</u><br>Attempts to normalise the image before parsing it to improve detection of a QR code.";
         this.infoURL = "https://wikipedia.org/wiki/QR_code";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
         this.args = [
             {
-                "name": "Normalise image",
-                "type": "boolean",
-                "value": false
-            }
+                name: "Normalise image",
+                type: "boolean",
+                value: false,
+            },
         ];
         this.checks = [
             {
-                "pattern": "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)",
-                "flags": "",
-                "args": [false],
-                "useful": true
-            }
+                pattern:
+                    "^(?:\\xff\\xd8\\xff|\\x89\\x50\\x4e\\x47|\\x47\\x49\\x46|.{8}\\x57\\x45\\x42\\x50|\\x42\\x4d)",
+                flags: "",
+                args: [false],
+                useful: true,
+            },
         ];
     }
 
@@ -54,9 +55,8 @@ class ParseQRCode extends Operation {
         if (!isImage(input)) {
             throw new OperationError("Invalid file type.");
         }
-        return await parseQrCode(input, normalise);
+        return parseQrCode(input, normalise);
     }
-
 }
 
 export default ParseQRCode;

package/src/core/operations/PseudoRandomIntegerGenerator.mjs

@@ -0,0 +1,164 @@
+/**
+ * @author cktgh [chankaitung@gmail.com]
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import forge from "node-forge";
+import Utils, { isWorkerEnvironment } from "../Utils.mjs";
+import { DELIM_OPTIONS } from "../lib/Delim.mjs";
+
+/**
+ * Pseudo-Random Integer Generator operation
+ */
+class PseudoRandomIntegerGenerator extends Operation {
+
+    // in theory 2**53 is the max range, but we use Number.MAX_SAFE_INTEGER (2**53 - 1) as it is more consistent.
+    static MAX_RANGE = Number.MAX_SAFE_INTEGER;
+    // arbitrary choice
+    static BUFFER_SIZE = 1024;
+
+    /**
+     * PseudoRandomIntegerGenerator constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Pseudo-Random Integer Generator";
+        this.module = "Ciphers";
+        this.description = "A cryptographically-secure pseudo-random number generator (PRNG).<br><br>Generates random integers within a specified range using the browser's built-in <code>crypto.getRandomValues()</code> method if available.<br><br>The supported range of integers is from <code>-(2^53 - 1)</code> to <code>(2^53 - 1)</code>.";
+        this.infoURL = "https://wikipedia.org/wiki/Pseudorandom_number_generator";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Number of Integers",
+                "type": "number",
+                "value": 1,
+                "min": 1
+            },
+            {
+                "name": "Min Value",
+                "type": "number",
+                "value": 0,
+                "min": Number.MIN_SAFE_INTEGER,
+                "max": Number.MAX_SAFE_INTEGER
+            },
+            {
+                "name": "Max Value",
+                "type": "number",
+                "value": 99,
+                "min": Number.MIN_SAFE_INTEGER,
+                "max": Number.MAX_SAFE_INTEGER
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Raw", "Hex", "Decimal"]
+            }
+        ];
+
+        // not using BigUint64Array to avoid BigInt handling overhead
+        this.randomBuffer = new Uint32Array(PseudoRandomIntegerGenerator.BUFFER_SIZE);
+        this.randomBufferOffset = PseudoRandomIntegerGenerator.BUFFER_SIZE;
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [numInts, minInt, maxInt, delimiter, outputType] = args;
+
+        if (minInt === null || maxInt === null) return "";
+
+        const min = Math.ceil(minInt);
+        const max = Math.floor(maxInt);
+        const delim = Utils.charRep(delimiter || "Space");
+
+        if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
+            throw new OperationError("Min and Max must be between `-(2^53 - 1)` and `2^53 - 1`.");
+        }
+        if (min > max) {
+            throw new OperationError("Min cannot be larger than Max.");
+        }
+        const range = max - min + 1; // inclusive range
+        if (range > PseudoRandomIntegerGenerator.MAX_RANGE) {
+            throw new OperationError("Range between Min and Max cannot be larger than `2^53`");
+        }
+
+        // as large as possible while divisible by range
+        const rejectionThreshold = PseudoRandomIntegerGenerator.MAX_RANGE - (PseudoRandomIntegerGenerator.MAX_RANGE % range);
+        const output = [];
+        for (let i = 0; i < numInts; i++) {
+            const result = this._generateRandomValue(rejectionThreshold);
+            const intValue = min + (result % range);
+
+            switch (outputType) {
+                case "Hex":
+                    output.push(intValue.toString(16));
+                    break;
+                case "Decimal":
+                    output.push(intValue.toString(10));
+                    break;
+                case "Raw":
+                default:
+                    output.push(Utils.chr(intValue));
+            }
+        }
+
+        if (outputType === "Raw") {
+            return output.join("");
+        }
+        return output.join(delim);
+    }
+
+    /**
+     * Generate a random value, result will be less than the rejection threshold (exclusive).
+     *
+     * @param {number} rejectionThreshold
+     * @returns {number}
+     */
+    _generateRandomValue(rejectionThreshold) {
+        let result;
+        do {
+            if (this.randomBufferOffset + 2 > this.randomBuffer.length) {
+                this._resetRandomBuffer();
+            }
+            // stitching a 53 bit number; not using BigUint64Array to avoid BigInt handling overhead
+            result = (this.randomBuffer[this.randomBufferOffset++] & 0x1f_ffff) * 0x1_0000_0000 +
+                this.randomBuffer[this.randomBufferOffset++];
+        } while (result >= rejectionThreshold);
+
+        return result;
+    }
+
+    /**
+     * Fill random buffer with new random values and rseet the offset.
+     */
+    _resetRandomBuffer() {
+        if (isWorkerEnvironment() && self.crypto) {
+            self.crypto.getRandomValues(this.randomBuffer);
+        } else {
+            const bytes = forge.random.getBytesSync(this.randomBuffer.length * 4);
+            for (let j = 0; j < this.randomBuffer.length; j++) {
+                this.randomBuffer[j] = (bytes.charCodeAt(j * 4) << 24) |
+                    (bytes.charCodeAt(j * 4 + 1) << 16) |
+                    (bytes.charCodeAt(j * 4 + 2) << 8) |
+                    bytes.charCodeAt(j * 4 + 3);
+            }
+        }
+        this.randomBufferOffset = 0;
+    }
+
+}
+
+export default PseudoRandomIntegerGenerator;

package/src/core/operations/RC6Decrypt.mjs

@@ -0,0 +1,119 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { toHex } from "../lib/Hex.mjs";
+import { decryptRC6, getBlockSize, getDefaultRounds } from "../lib/RC6.mjs";
+
+/**
+ * RC6 Decrypt operation
+ */
+class RC6Decrypt extends Operation {
+
+    /**
+     * RC6Decrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "RC6 Decrypt";
+        this.module = "Ciphers";
+        this.description = "RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.<br><br>RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.<br><br><b>IV:</b> The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, the PKCS#7 padding scheme is used.";
+        this.infoURL = "https://wikipedia.org/wiki/RC6";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "IV",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Mode",
+                "type": "option",
+                "value": ["CBC", "CFB", "OFB", "CTR", "ECB"]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": ["Hex", "Raw"]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            },
+            {
+                "name": "Padding",
+                "type": "option",
+                "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"]
+            },
+            {
+                "name": "Word Size",
+                "type": "number",
+                "value": 32,
+                "min": 8,
+                "max": 256,
+                "step": 8
+            },
+            {
+                "name": "Rounds",
+                "type": "number",
+                "value": 20,
+                "min": 1,
+                "max": 255
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const key = Utils.convertToByteArray(args[0].string, args[0].option),
+            iv = Utils.convertToByteArray(args[1].string, args[1].option),
+            [,, mode, inputType, outputType, padding, wordSize, rounds] = args;
+
+        // Validate word size
+        if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0)
+            throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`);
+
+        const blockSize = getBlockSize(wordSize);
+        const defaultRounds = getDefaultRounds(wordSize);
+
+        if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB")
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes
+
+RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits).
+Make sure you have specified the type correctly (e.g. Hex vs UTF8).`);
+
+        if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255)
+            throw new OperationError(`Invalid number of rounds: ${rounds}
+
+Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`);
+
+        // Default IV to null bytes if empty (like AES)
+        const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv;
+
+        input = Utils.convertToByteArray(input, inputType);
+        const output = decryptRC6(input, key, actualIv, mode, padding, rounds, wordSize);
+        return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output);
+    }
+
+}
+
+export default RC6Decrypt;

package/src/core/operations/RC6Encrypt.mjs

@@ -0,0 +1,119 @@
+/**
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { toHex } from "../lib/Hex.mjs";
+import { encryptRC6, getBlockSize, getDefaultRounds } from "../lib/RC6.mjs";
+
+/**
+ * RC6 Encrypt operation
+ */
+class RC6Encrypt extends Operation {
+
+    /**
+     * RC6Encrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "RC6 Encrypt";
+        this.module = "Ciphers";
+        this.description = "RC6 is a symmetric key block cipher derived from RC5. It was designed by Ron Rivest, Matt Robshaw, Ray Sidney, and Yiqun Lisa Yin to meet the requirements of the AES competition, and was one of the five finalists.<br><br>RC6 is parameterised as RC6-w/r/b where w is word size in bits (any multiple of 8 from 8-256), r is the number of rounds (1-255), and b is the key length in bytes. The standard AES submission uses w=32, r=20. Common word sizes: 8, 16, 32 (standard), 64, 128.<br><br><b>IV:</b> The Initialisation Vector should be 4*w/8 bytes (e.g. 16 bytes for w=32). If not entered, it will default to null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, the PKCS#7 padding scheme is used.";
+        this.infoURL = "https://wikipedia.org/wiki/RC6";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "IV",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Mode",
+                "type": "option",
+                "value": ["CBC", "CFB", "OFB", "CTR", "ECB"]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Hex", "Raw"]
+            },
+            {
+                "name": "Padding",
+                "type": "option",
+                "value": ["PKCS5", "NO", "ZERO", "RANDOM", "BIT"]
+            },
+            {
+                "name": "Word Size",
+                "type": "number",
+                "value": 32,
+                "min": 8,
+                "max": 256,
+                "step": 8
+            },
+            {
+                "name": "Rounds",
+                "type": "number",
+                "value": 20,
+                "min": 1,
+                "max": 255
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const key = Utils.convertToByteArray(args[0].string, args[0].option),
+            iv = Utils.convertToByteArray(args[1].string, args[1].option),
+            [,, mode, inputType, outputType, padding, wordSize, rounds] = args;
+
+        // Validate word size
+        if (!Number.isInteger(wordSize) || wordSize < 8 || wordSize > 256 || wordSize % 8 !== 0)
+            throw new OperationError(`Invalid word size: ${wordSize}. Must be a multiple of 8 between 8 and 256.`);
+
+        const blockSize = getBlockSize(wordSize);
+        const defaultRounds = getDefaultRounds(wordSize);
+
+        if (iv.length !== blockSize && iv.length !== 0 && mode !== "ECB")
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes
+
+RC6-${wordSize} uses an IV length of ${blockSize} bytes (${blockSize * 8} bits).
+Make sure you have specified the type correctly (e.g. Hex vs UTF8).`);
+
+        if (!Number.isInteger(rounds) || rounds < 1 || rounds > 255)
+            throw new OperationError(`Invalid number of rounds: ${rounds}
+
+Rounds must be an integer between 1 and 255. Standard for w=${wordSize} is ${defaultRounds}.`);
+
+        // Default IV to null bytes if empty (like AES)
+        const actualIv = iv.length === 0 ? new Array(blockSize).fill(0) : iv;
+
+        input = Utils.convertToByteArray(input, inputType);
+        const output = encryptRC6(input, key, actualIv, mode, padding, rounds, wordSize);
+        return outputType === "Hex" ? toHex(output, "") : Utils.byteArrayToUtf8(output);
+    }
+
+}
+
+export default RC6Encrypt;