cyberchef 10.22.1 → 10.23.0

package/src/core/operations/EscapeUnicodeCharacters.mjs

@@ -44,23 +44,6 @@ class EscapeUnicodeCharacters extends Operation {
                 "value": true
             }
         ];
-        this.checks = [
-            {
-                pattern: "\\\\u(?:[\\da-f]{4,6})",
-                flags: "i",
-                args: ["\\u"]
-            },
-            {
-                pattern: "%u(?:[\\da-f]{4,6})",
-                flags: "i",
-                args: ["%u"]
-            },
-            {
-                pattern: "U\\+(?:[\\da-f]{4,6})",
-                flags: "i",
-                args: ["U+"]
-            }
-        ];
     }
 
     /**

package/src/core/operations/ExtractAudioMetadata.mjs

@@ -0,0 +1,175 @@
+/**
+ * @author d0s1nt [d0s1nt@cyberchefaudio]
+ * @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 { makeEmptyReport, sniffContainer } from "../lib/AudioMetaSchema.mjs";
+import {
+    parseMp3, parseRiffWave, parseFlac, parseOgg,
+    parseMp4BestEffort, parseAiffBestEffort,
+    parseAacAdts, parseAc3, parseWmaAsf,
+} from "../lib/AudioParsers.mjs";
+
+/**
+ * Extract Audio Metadata operation.
+ */
+class ExtractAudioMetadata extends Operation {
+    /** Creates the Extract Audio Metadata operation. */
+    constructor() {
+        super();
+
+        this.name = "Extract Audio Metadata";
+        this.module = "Default";
+        this.description =
+            "Extract common audio metadata across MP3 (ID3v2/ID3v1/GEOB), WAV/BWF/BW64 (INFO/bext/iXML/axml), FLAC (Vorbis Comment/Picture), OGG (Vorbis/OpusTags), AAC (ADTS), AC3 (Dolby Digital), WMA (ASF), plus best-effort MP4/M4A and AIFF scanning. Outputs normalized JSON.";
+        this.infoURL = "https://wikipedia.org/wiki/Audio_file_format";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "JSON";
+        this.presentType = "html";
+
+        this.args = [
+            { name: "Filename (optional)", type: "string", value: "" },
+            { name: "Max embedded text bytes (iXML/axml/etc)", type: "number", value: 1024 * 512 },
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {Object}
+     */
+    run(input, args) {
+        const filename = (args?.[0] || "").trim() || null;
+        const maxTextBytes = Number.isFinite(args?.[1]) ? Math.max(1024, args[1]) : 1024 * 512;
+
+        if (!(input instanceof ArrayBuffer) || input.byteLength === 0)
+            throw new OperationError("No input data. Load an audio file (drag/drop or use the open file button).");
+
+        const bytes = new Uint8Array(input);
+        const container = sniffContainer(bytes);
+        const report = makeEmptyReport(filename, bytes.length, container);
+
+        try {
+            const parsers = {
+                mp3: () => parseMp3(bytes, report),
+                wav: () => parseRiffWave(bytes, report, maxTextBytes),
+                bw64: () => parseRiffWave(bytes, report, maxTextBytes),
+                flac: () => parseFlac(bytes, report, maxTextBytes),
+                ogg: () => parseOgg(bytes, report),
+                opus: () => parseOgg(bytes, report),
+                mp4: () => parseMp4BestEffort(bytes, report),
+                m4a: () => parseMp4BestEffort(bytes, report),
+                aiff: () => parseAiffBestEffort(bytes, report, maxTextBytes),
+                aac: () => parseAacAdts(bytes, report),
+                ac3: () => parseAc3(bytes, report),
+                wma: () => parseWmaAsf(bytes, report),
+            };
+            if (parsers[container.type]) {
+                parsers[container.type]();
+            } else {
+                report.errors.push({ stage: "sniff", message: "Unknown/unsupported container (best-effort scan not implemented)." });
+            }
+        } catch (e) {
+            report.errors.push({ stage: "parse", message: String(e?.message || e) });
+        }
+
+        return report;
+    }
+
+    /** Renders the extracted metadata as an HTML table. */
+    present(data) {
+        if (!data || typeof data !== "object") return JSON.stringify(data, null, 4);
+
+        const esc = Utils.escapeHtml;
+        const row = (k, v) => `<tr><td>${esc(String(k))}</td><td>${esc(String(v ?? ""))}</td></tr>\n`;
+        const section = (title) => `<tr><th colspan="2" style="background:#e9ecef;text-align:center">${esc(title)}</th></tr>\n`;
+        const objRows = (obj, filter = (v) => v !== null) => {
+            for (const [k, v] of Object.entries(obj)) {
+                if (filter(v)) html += row(k, v);
+            }
+        };
+        const objSection = (obj, title, filter) => {
+            if (!obj) return;
+            html += section(title);
+            objRows(obj, filter);
+        };
+        const listSection = (arr, title, fmt) => {
+            if (!arr?.length) return;
+            html += section(title);
+            for (const item of arr) html += fmt(item);
+        };
+
+        let html = `<table class="table table-hover table-sm table-bordered table-nonfluid">\n`;
+
+        html += section("Artifact");
+        html += row("Filename", data.artifact?.filename || "(none)");
+        html += row("Size", `${(data.artifact?.byte_length ?? 0).toLocaleString()} bytes`);
+        html += row("Container", data.artifact?.container?.type);
+        html += row("MIME", data.artifact?.container?.mime);
+        if (data.artifact?.container?.brand) html += row("Brand", data.artifact.container.brand);
+
+        html += section("Detections");
+        html += row("Metadata systems", (data.detections?.metadata_systems || []).join(", ") || "None");
+        html += row("Provenance systems", (data.detections?.provenance_systems || []).join(", ") || "None");
+
+        const common = data.tags?.common || {};
+        html += section("Common Tags");
+        if (Object.values(common).some((v) => v !== null)) {
+            for (const [key, val] of Object.entries(common)) {
+                if (val !== null) html += row(key.charAt(0).toUpperCase() + key.slice(1), val);
+            }
+        } else {
+            html += row("(none)", "No common tags found");
+        }
+
+        listSection(data.tags?.raw?.id3v2?.frames, "ID3v2 Frames", (f) => {
+            const val = typeof f.decoded === "object" ? JSON.stringify(f.decoded) : (f.decoded ?? `(${f.size} bytes)`);
+            return row(f.id + (f.description ? ` \u2014 ${f.description}` : ""), val);
+        });
+        objSection(data.tags?.raw?.id3v1, "ID3v1", (v) => !!v);
+        listSection(data.tags?.raw?.apev2?.items, "APEv2 Tags", (i) => row(i.key, i.value));
+
+        if (data.tags?.raw?.vorbis_comments?.comments?.length) {
+            html += section("Vorbis Comments");
+            html += row("Vendor", data.tags.raw.vorbis_comments.vendor);
+            for (const c of data.tags.raw.vorbis_comments.comments) html += row(c.key, c.value);
+        }
+
+        objSection(data.tags?.raw?.riff?.info, "RIFF INFO", () => true);
+        objSection(data.tags?.raw?.riff?.bext, "BWF bext");
+        listSection(data.tags?.raw?.riff?.chunks, "RIFF Chunks", (c) => row(c.id, `${c.size} bytes @ offset ${c.offset}`));
+        listSection(data.tags?.raw?.flac?.blocks, "FLAC Metadata Blocks", (b) => row(b.type, `${b.length} bytes`));
+
+        if (data.tags?.raw?.mp4?.top_level_atoms?.length) {
+            html += section("MP4 Top-Level Atoms");
+            const atoms = data.tags.raw.mp4.top_level_atoms;
+            for (const a of atoms.slice(0, 50)) html += row(a.type, `${a.size} bytes @ offset ${a.offset}`);
+            if (atoms.length > 50) html += row("...", `${atoms.length - 50} more atoms`);
+        }
+
+        listSection(data.tags?.raw?.aiff?.chunks, "AIFF Chunks", (c) => row(c.id, c.value));
+        objSection(data.tags?.raw?.aac, "AAC ADTS");
+        objSection(data.tags?.raw?.ac3, "AC3 (Dolby Digital)");
+        objSection(data.tags?.raw?.asf?.content_description, "ASF Content Description", (v) => !!v);
+        listSection(data.tags?.raw?.asf?.extended_content, "ASF Extended Content", (d) => row(d.name, d.value));
+        listSection(data.embedded, "Embedded Objects", (e) => row(e.id, `${e.content_type || "unknown"} \u2014 ${(e.byte_length ?? 0).toLocaleString()} bytes`));
+
+        if (data.provenance?.c2pa?.present) {
+            html += section("C2PA Provenance");
+            html += row("Present", "Yes");
+            for (const emb of (data.provenance.c2pa.embedding || []))
+                html += row("Carrier", `${emb.carrier} \u2014 ${(emb.byte_length ?? 0).toLocaleString()} bytes`);
+        }
+
+        listSection(data.errors, "Errors", (e) => row(e.stage, e.message));
+
+        html += "</table>";
+        return html;
+    }
+}
+
+export default ExtractAudioMetadata;

package/src/core/operations/ExtractLSB.mjs

@@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.mjs";
 import { fromBinary } from "../lib/Binary.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp } from "jimp";
 
 /**
  * Extract LSB operation
  */
 class ExtractLSB extends Operation {
-
     /**
      * ExtractLSB constructor
      */
@@ -24,8 +23,10 @@ class ExtractLSB extends Operation {
 
         this.name = "Extract LSB";
         this.module = "Image";
-        this.description = "Extracts the Least Significant Bit data from each pixel in an image. This is a common way to hide data in Steganography.";
-        this.infoURL = "https://wikipedia.org/wiki/Bit_numbering#Least_significant_bit_in_digital_steganography";
+        this.description =
+            "Extracts the Least Significant Bit data from each pixel in an image. This is a common way to hide data in Steganography.";
+        this.infoURL =
+            "https://wikipedia.org/wiki/Bit_numbering#Least_significant_bit_in_digital_steganography";
         this.inputType = "ArrayBuffer";
         this.outputType = "byteArray";
         this.args = [
@@ -57,8 +58,8 @@ class ExtractLSB extends Operation {
             {
                 name: "Bit",
                 type: "number",
-                value: 0
-            }
+                value: 0,
+            },
         ];
     }
 
@@ -68,21 +69,27 @@ class ExtractLSB extends Operation {
      * @returns {byteArray}
      */
     async run(input, args) {
-        if (!isImage(input)) throw new OperationError("Please enter a valid image file.");
+        if (!isImage(input))
+            throw new OperationError("Please enter a valid image file.");
 
         const bit = 7 - args.pop(),
             pixelOrder = args.pop(),
-            colours = args.filter(option => option !== "").map(option => COLOUR_OPTIONS.indexOf(option)),
+            colours = args
+                .filter((option) => option !== "")
+                .map((option) => COLOUR_OPTIONS.indexOf(option)),
             parsedImage = await Jimp.read(input),
             width = parsedImage.bitmap.width,
             height = parsedImage.bitmap.height,
             rgba = parsedImage.bitmap.data;
 
         if (bit < 0 || bit > 7) {
-            throw new OperationError("Error: Bit argument must be between 0 and 7");
+            throw new OperationError(
+                "Error: Bit argument must be between 0 and 7",
+            );
         }
 
-        let i, combinedBinary = "";
+        let i,
+            combinedBinary = "";
 
         if (pixelOrder === "Row") {
             for (i = 0; i < rgba.length; i += 4) {
@@ -106,7 +113,6 @@ class ExtractLSB extends Operation {
 
         return fromBinary(combinedBinary);
     }
-
 }
 
 const COLOUR_OPTIONS = ["R", "G", "B", "A"];

package/src/core/operations/ExtractRGBA.mjs

@@ -7,15 +7,14 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp } from "jimp";
 
-import {RGBA_DELIM_OPTIONS} from "../lib/Delim.mjs";
+import { RGBA_DELIM_OPTIONS } from "../lib/Delim.mjs";
 
 /**
  * Extract RGBA operation
  */
 class ExtractRGBA extends Operation {
-
     /**
      * ExtractRGBA constructor
      */
@@ -24,7 +23,8 @@ class ExtractRGBA extends Operation {
 
         this.name = "Extract RGBA";
         this.module = "Image";
-        this.description = "Extracts each pixel's RGBA value in an image. These are sometimes used in Steganography to hide text or data.";
+        this.description =
+            "Extracts each pixel's RGBA value in an image. These are sometimes used in Steganography to hide text or data.";
         this.infoURL = "https://wikipedia.org/wiki/RGBA_color_space";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
@@ -32,13 +32,13 @@ class ExtractRGBA extends Operation {
             {
                 name: "Delimiter",
                 type: "editableOption",
-                value: RGBA_DELIM_OPTIONS
+                value: RGBA_DELIM_OPTIONS,
             },
             {
                 name: "Include Alpha",
                 type: "boolean",
-                value: true
-            }
+                value: true,
+            },
         ];
     }
 
@@ -48,18 +48,20 @@ class ExtractRGBA extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        if (!isImage(input)) throw new OperationError("Please enter a valid image file.");
+        if (!isImage(input))
+            throw new OperationError("Please enter a valid image file.");
 
         const delimiter = args[0],
             includeAlpha = args[1],
             parsedImage = await Jimp.read(input);
 
         let bitmap = parsedImage.bitmap.data;
-        bitmap = includeAlpha ? bitmap : bitmap.filter((val, idx) => idx % 4 !== 3);
+        bitmap = includeAlpha ?
+            bitmap :
+            bitmap.filter((val, idx) => idx % 4 !== 3);
 
         return bitmap.join(delimiter);
     }
-
 }
 
 export default ExtractRGBA;

package/src/core/operations/FlaskSessionDecode.mjs

@@ -0,0 +1,80 @@
+/**
+ * @author ThePlayer372-FR []
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromBase64 } from "../lib/Base64.mjs";
+
+/**
+ * Flask Session Decode operation
+ */
+class FlaskSessionDecode extends Operation {
+    /**
+     * FlaskSessionDecode constructor
+    */
+    constructor() {
+        super();
+
+        this.name = "Flask Session Decode";
+        this.module = "Crypto";
+        this.description = "Decodes the payload of a Flask session cookie (itsdangerous) into JSON.";
+        this.inputType = "string";
+        this.outputType = "JSON";
+        this.args = [
+            {
+                name: "View TimeStamp",
+                type: "boolean",
+                value: false
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {Object[]}
+     */
+    run(input, args) {
+        input = input.trim();
+        const parts = input.split(".");
+        if (parts.length !== 3) {
+            throw new OperationError("Invalid Flask token format. Expected payload.timestamp.signature");
+        }
+
+        const payloadB64 = parts[0];
+        const time = parts[1];
+
+        const timeB64 = time.replace(/-/g, "+").replace(/_/g, "/");
+        const binary = fromBase64(timeB64);
+        const bytes = new Uint8Array(4);
+        for (let i = 0; i < 4; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        const view = new DataView(bytes.buffer);
+        const timestamp = view.getInt32(0, false);
+
+        const base64 = payloadB64.replace(/-/g, "+").replace(/_/g, "/");
+        const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+        let payloadJson;
+        try {
+            payloadJson = fromBase64(padded);
+        } catch (e) {
+            throw new OperationError("Invalid Base64 payload");
+        }
+
+        try {
+            let data = JSON.parse(payloadJson);
+
+            if (args[0]) {
+                data = {payload: data, timestamp: timestamp};
+            }
+            return data;
+        } catch (e) {
+            throw new OperationError("Unable to decode JSON payload: " + e.message);
+        }
+    }
+}
+
+export default FlaskSessionDecode;

package/src/core/operations/FlaskSessionSign.mjs

@@ -0,0 +1,89 @@
+/**
+ * @author ThePlayer372-FR []
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import CryptoApi from "crypto-api/src/crypto-api.mjs";
+import Utils from "../Utils.mjs";
+import { toBase64 } from "../lib/Base64.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Flask Session Sign operation
+ */
+class FlaskSessionSign extends Operation {
+    /**
+     * FlaskSessionSign constructor
+    */
+    constructor() {
+        super();
+
+        this.name = "Flask Session Sign";
+        this.module = "Crypto";
+        this.description = "Signs a JSON payload to produce a Flask session cookie (itsdangerous HMAC).";
+        this.inputType = "JSON";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "Decimal", "Binary", "Base64", "UTF8", "Latin1"]
+            },
+            {
+                name: "Salt",
+                type: "toggleString",
+                value: "cookie-session",
+                toggleValues: ["UTF8", "Hex", "Decimal", "Binary", "Base64", "Latin1"]
+            },
+            {
+                name: "Algorithm",
+                type: "option",
+                value: ["sha1", "sha256"],
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        if (!args[0].string) {
+            throw new OperationError("Secret key required");
+        }
+        const key = Utils.convertToByteString(args[0].string, args[0].option);
+        const salt = Utils.convertToByteString(args[1].string || "cookie-session", args[1].option);
+        const algorithm = args[2] || "sha1";
+
+        const payloadB64 = toBase64(Utils.strToByteArray(JSON.stringify(input)));
+        const payload = payloadB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+
+        const derivedKey = CryptoApi.getHmac(key, CryptoApi.getHasher(algorithm));
+        derivedKey.update(salt);
+
+        const currentTimeStamp = Math.ceil(Date.now() / 1000);
+        const buffer = new ArrayBuffer(4);
+        const view = new DataView(buffer);
+        view.setInt32(0, currentTimeStamp, false);
+        const bytes = new Uint8Array(buffer);
+        let binary = "";
+        bytes.forEach(b => binary += String.fromCharCode(b));
+        const timeB64 = toBase64(Utils.strToByteArray(binary));
+        const time = timeB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+
+        const data = Utils.convertToByteString(payload + "." + time, "utf8");
+        const sign = CryptoApi.getHmac(derivedKey.finalize(), CryptoApi.getHasher(algorithm));
+        sign.update(data);
+
+        const signB64 = toBase64(sign.finalize());
+        const sign64 = signB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+
+        return payload + "." + time + "." + sign64;
+    }
+}
+
+
+export default FlaskSessionSign;

package/src/core/operations/FlaskSessionVerify.mjs

@@ -0,0 +1,136 @@
+/**
+ * @author ThePlayer372-FR []
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import CryptoApi from "crypto-api/src/crypto-api.mjs";
+import Utils from "../Utils.mjs";
+import { toBase64, fromBase64 } from "../lib/Base64.mjs";
+
+/**
+ * Flask Session Verify operation
+ */
+class FlaskSessionVerify extends Operation {
+    /**
+     * FlaskSessionVerify constructor
+    */
+    constructor() {
+        super();
+
+        this.name = "Flask Session Verify";
+        this.module = "Crypto";
+        this.description = "Verifies the HMAC signature of a Flask session cookie (itsdangerous) generated.";
+        this.inputType = "string";
+        this.outputType = "JSON";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "Decimal", "Binary", "Base64", "UTF8", "Latin1"]
+            },
+            {
+                name: "Salt",
+                type: "toggleString",
+                value: "cookie-session",
+                toggleValues: ["UTF8", "Hex", "Decimal", "Binary", "Base64", "Latin1"]
+            },
+            {
+                name: "Algorithm",
+                type: "option",
+                value: ["sha1", "sha256"],
+            },
+            {
+                name: "View TimeStamp",
+                type: "boolean",
+                value: true
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+
+        if (!args[0].string) {
+            throw new OperationError("Secret key required");
+        }
+
+        const key = Utils.convertToByteString(args[0].string, args[0].option);
+        const salt = Utils.convertToByteString(args[1].string || "cookie-session", args[1].option);
+        const algorithm = args[2] || "sha1";
+
+        input = input.trim();
+
+        const parts = input.split(".");
+
+        if (parts.length !== 3) {
+            throw new OperationError("Invalid Flask token format. Expected payload.timestamp.signature");
+        }
+
+        const data = Utils.convertToByteString(parts[0] + "." + parts[1], "utf8");
+
+
+        const derivedKey = CryptoApi.getHmac(key, CryptoApi.getHasher(algorithm));
+        derivedKey.update(salt);
+
+        const sign = CryptoApi.getHmac(derivedKey.finalize(), CryptoApi.getHasher(algorithm));
+        sign.update(data);
+
+        const payloadB64 = parts[0];
+        const base64 = payloadB64.replace(/-/g, "+").replace(/_/g, "/");
+        const padded = base64.padEnd(Math.ceil(base64.length / 4) * 4, "=");
+
+        const time = parts[1];
+
+        const timeB64 = time.replace(/-/g, "+").replace(/_/g, "/");
+        const binary = fromBase64(timeB64);
+        const bytes = new Uint8Array(4);
+        for (let i = 0; i < 4; i++) {
+            bytes[i] = binary.charCodeAt(i);
+        }
+        const view = new DataView(bytes.buffer);
+        const timestamp = view.getInt32(0, false);
+
+        let payloadJson;
+        try {
+            payloadJson = fromBase64(padded);
+        } catch (e) {
+            throw new OperationError("Invalid Base64 payload");
+        }
+
+        const signB64 = toBase64(sign.finalize());
+        const sign64 = signB64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+
+        if (sign64 !== parts[2]) {
+            throw new OperationError("Invalid signature!");
+        }
+
+        try {
+            const decoded = JSON.parse(payloadJson);
+            if (!args[3]) {
+                return {
+                    valid: true,
+                    payload: decoded,
+                };
+            } else {
+                return {
+                    valid: true,
+                    payload: decoded,
+                    timestamp: timestamp
+                };
+            }
+        } catch (e) {
+            throw new OperationError("Unable to decode JSON payload: " + e.message);
+        }
+
+    }
+}
+
+
+export default FlaskSessionVerify;