cyberchef 10.22.1 → 10.23.0

package/src/core/operations/ConvertImageFormat.mjs

@@ -8,13 +8,12 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime, PNGFilterType } from "jimp";
 
 /**
  * Convert Image Format operation
  */
 class ConvertImageFormat extends Operation {
-
     /**
      * ConvertImageFormat constructor
      */
@@ -23,7 +22,8 @@ class ConvertImageFormat extends Operation {
 
         this.name = "Convert Image Format";
         this.module = "Image";
-        this.description = "Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted.";
+        this.description =
+            "Converts an image between different formats. Supported formats:<br><ul><li>Joint Photographic Experts Group (JPEG)</li><li>Portable Network Graphics (PNG)</li><li>Bitmap (BMP)</li><li>Tagged Image File Format (TIFF)</li></ul><br>Note: GIF files are supported for input, but cannot be outputted.";
         this.infoURL = "https://wikipedia.org/wiki/Image_file_formats";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -32,39 +32,27 @@ class ConvertImageFormat extends Operation {
             {
                 name: "Output Format",
                 type: "option",
-                value: [
-                    "JPEG",
-                    "PNG",
-                    "BMP",
-                    "TIFF"
-                ]
+                value: ["JPEG", "PNG", "BMP", "TIFF"],
             },
             {
                 name: "JPEG Quality",
                 type: "number",
                 value: 80,
                 min: 1,
-                max: 100
+                max: 100,
             },
             {
                 name: "PNG Filter Type",
                 type: "option",
-                value: [
-                    "Auto",
-                    "None",
-                    "Sub",
-                    "Up",
-                    "Average",
-                    "Paeth"
-                ]
+                value: ["Auto", "None", "Sub", "Up", "Average", "Paeth"],
             },
             {
                 name: "PNG Deflate Level",
                 type: "number",
                 value: 9,
                 min: 0,
-                max: 9
-            }
+                max: 9,
+            },
         ];
     }
 
@@ -76,19 +64,19 @@ class ConvertImageFormat extends Operation {
     async run(input, args) {
         const [format, jpegQuality, pngFilterType, pngDeflateLevel] = args;
         const formatMap = {
-            "JPEG": Jimp.MIME_JPEG,
-            "PNG": Jimp.MIME_PNG,
-            "BMP": Jimp.MIME_BMP,
-            "TIFF": Jimp.MIME_TIFF
+            JPEG: JimpMime.jpeg,
+            PNG: JimpMime.png,
+            BMP: JimpMime.bmp,
+            TIFF: JimpMime.tiff,
         };
 
         const pngFilterMap = {
-            "Auto": Jimp.PNG_FILTER_AUTO,
-            "None": Jimp.PNG_FILTER_NONE,
-            "Sub": Jimp.PNG_FILTER_SUB,
-            "Up": Jimp.PNG_FILTER_UP,
-            "Average": Jimp.PNG_FILTER_AVERAGE,
-            "Paeth": Jimp.PNG_FILTER_PATH
+            Auto: PNGFilterType.AUTO,
+            None: PNGFilterType.NONE,
+            Sub: PNGFilterType.SUB,
+            Up: PNGFilterType.UP,
+            Average: PNGFilterType.AVERAGE,
+            Paeth: PNGFilterType.PATH,
         };
 
         const mime = formatMap[format];
@@ -103,18 +91,25 @@ class ConvertImageFormat extends Operation {
             throw new OperationError(`Error opening image file. (${err})`);
         }
         try {
-            switch (format) {
-                case "JPEG":
-                    image.quality(jpegQuality);
+            let buffer;
+            switch (mime) {
+                case JimpMime.jpeg:
+                    buffer = await image.getBuffer(mime, {
+                        quality: jpegQuality,
+                    });
                     break;
-                case "PNG":
-                    image.filterType(pngFilterMap[pngFilterType]);
-                    image.deflateLevel(pngDeflateLevel);
+                case JimpMime.png:
+                    buffer = await image.getBuffer(mime, {
+                        filterType: pngFilterMap[pngFilterType],
+                        deflateLevel: pngDeflateLevel,
+                    });
+                    break;
+                default:
+                    buffer = await image.getBuffer(mime);
                     break;
             }
 
-            const imageBuffer = await image.getBufferAsync(mime);
-            return imageBuffer.buffer;
+            return buffer.buffer;
         } catch (err) {
             throw new OperationError(`Error converting image format. (${err})`);
         }
@@ -137,7 +132,6 @@ class ConvertImageFormat extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ConvertImageFormat;

package/src/core/operations/CoverImage.mjs

@@ -9,13 +9,18 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimp from "jimp/es/index.js";
+import {
+    Jimp,
+    JimpMime,
+    ResizeStrategy,
+    HorizontalAlign,
+    VerticalAlign,
+} from "jimp";
 
 /**
  * Cover Image operation
  */
 class CoverImage extends Operation {
-
     /**
      * CoverImage constructor
      */
@@ -24,7 +29,8 @@ class CoverImage extends Operation {
 
         this.name = "Cover Image";
         this.module = "Image";
-        this.description = "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
+        this.description =
+            "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,33 +40,25 @@ class CoverImage extends Operation {
                 name: "Width",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Horizontal align",
                 type: "option",
-                value: [
-                    "Left",
-                    "Center",
-                    "Right"
-                ],
-                defaultIndex: 1
+                value: ["Left", "Center", "Right"],
+                defaultIndex: 1,
             },
             {
                 name: "Vertical align",
                 type: "option",
-                value: [
-                    "Top",
-                    "Middle",
-                    "Bottom"
-                ],
-                defaultIndex: 1
+                value: ["Top", "Middle", "Bottom"],
+                defaultIndex: 1,
             },
             {
                 name: "Resizing algorithm",
@@ -70,10 +68,10 @@ class CoverImage extends Operation {
                     "Bilinear",
                     "Bicubic",
                     "Hermite",
-                    "Bezier"
+                    "Bezier",
                 ],
-                defaultIndex: 1
-            }
+                defaultIndex: 1,
+            },
         ];
     }
 
@@ -86,20 +84,20 @@ class CoverImage extends Operation {
         const [width, height, hAlign, vAlign, alg] = args;
 
         const resizeMap = {
-            "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
-            "Bilinear": jimp.RESIZE_BILINEAR,
-            "Bicubic": jimp.RESIZE_BICUBIC,
-            "Hermite": jimp.RESIZE_HERMITE,
-            "Bezier": jimp.RESIZE_BEZIER
+            "Nearest Neighbour": ResizeStrategy.NEAREST_NEIGHBOR,
+            Bilinear: ResizeStrategy.BILINEAR,
+            Bicubic: ResizeStrategy.BICUBIC,
+            Hermite: ResizeStrategy.HERMITE,
+            Bezier: ResizeStrategy.BEZIER,
         };
 
         const alignMap = {
-            "Left": jimp.HORIZONTAL_ALIGN_LEFT,
-            "Center": jimp.HORIZONTAL_ALIGN_CENTER,
-            "Right": jimp.HORIZONTAL_ALIGN_RIGHT,
-            "Top": jimp.VERTICAL_ALIGN_TOP,
-            "Middle": jimp.VERTICAL_ALIGN_MIDDLE,
-            "Bottom": jimp.VERTICAL_ALIGN_BOTTOM
+            Left: HorizontalAlign.LEFT,
+            Center: HorizontalAlign.CENTER,
+            Right: HorizontalAlign.RIGHT,
+            Top: VerticalAlign.TOP,
+            Middle: VerticalAlign.MIDDLE,
+            Bottom: VerticalAlign.BOTTOM,
         };
 
         if (!isImage(input)) {
@@ -108,19 +106,24 @@ class CoverImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
         try {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Covering image...");
-            image.cover(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+            image.cover({
+                w: width,
+                h: height,
+                align: alignMap[hAlign] | alignMap[vAlign],
+                mode: resizeMap[alg],
+            });
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+            if (image.mime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBuffer(image.mime);
             }
             return imageBuffer.buffer;
         } catch (err) {
@@ -144,7 +147,6 @@ class CoverImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default CoverImage;

package/src/core/operations/CropImage.mjs

@@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Crop Image operation
  */
 class CropImage extends Operation {
-
     /**
      * CropImage constructor
      */
@@ -24,7 +23,8 @@ class CropImage extends Operation {
 
         this.name = "Crop Image";
         this.module = "Image";
-        this.description = "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
+        this.description =
+            "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
         this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,30 +34,30 @@ class CropImage extends Operation {
                 name: "X Position",
                 type: "number",
                 value: 0,
-                min: 0
+                min: 0,
             },
             {
                 name: "Y Position",
                 type: "number",
                 value: 0,
-                min: 0
+                min: 0,
             },
             {
                 name: "Width",
                 type: "number",
                 value: 10,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 10,
-                min: 1
+                min: 1,
             },
             {
                 name: "Autocrop",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Autocrop tolerance (%)",
@@ -65,24 +65,24 @@ class CropImage extends Operation {
                 value: 0.02,
                 min: 0,
                 max: 100,
-                step: 0.01
+                step: 0.01,
             },
             {
                 name: "Only autocrop frames",
                 type: "boolean",
-                value: true
+                value: true,
             },
             {
                 name: "Symmetric autocrop",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Autocrop keep border (px)",
                 type: "number",
                 value: 0,
-                min: 0
-            }
+                min: 0,
+            },
         ];
     }
 
@@ -92,7 +92,17 @@ class CropImage extends Operation {
      * @returns {byteArray}
      */
     async run(input, args) {
-        const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args;
+        const [
+            xPos,
+            yPos,
+            width,
+            height,
+            autocrop,
+            autoTolerance,
+            autoFrames,
+            autoSymmetric,
+            autoBorder,
+        ] = args;
         if (!isImage(input)) {
             throw new OperationError("Invalid file type.");
         }
@@ -108,20 +118,25 @@ class CropImage extends Operation {
                 self.sendStatusMessage("Cropping image...");
             if (autocrop) {
                 image.autocrop({
-                    tolerance: (autoTolerance / 100),
+                    tolerance: autoTolerance / 100,
                     cropOnlyFrames: autoFrames,
                     cropSymmetric: autoSymmetric,
-                    leaveBorder: autoBorder
+                    leaveBorder: autoBorder,
                 });
             } else {
-                image.crop(xPos, yPos, width, height);
+                image.crop({
+                    x: xPos,
+                    y: yPos,
+                    w: width,
+                    h: height,
+                });
             }
 
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+            if (image.mime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
+                imageBuffer = await image.getBuffer(image.mime);
             }
             return imageBuffer.buffer;
         } catch (err) {
@@ -145,7 +160,6 @@ class CropImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default CropImage;

package/src/core/operations/DisassembleARM.mjs

@@ -0,0 +1,193 @@
+/**
+ * @author MedjedThomasXM
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { isWorkerEnvironment } from "../Utils.mjs";
+import cs from "@alexaltea/capstone-js/dist/capstone.min.js";
+
+/**
+ * Disassemble ARM operation
+ */
+class DisassembleARM extends Operation {
+
+    /**
+     * DisassembleARM constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Disassemble ARM";
+        this.module = "Shellcode";
+        this.description = "Disassembles ARM machine code into assembly language.<br><br>Supports ARM (32-bit), Thumb, and ARM64 (AArch64) architectures using the Capstone disassembly framework.<br><br>Input should be in hexadecimal.";
+        this.infoURL = "https://wikipedia.org/wiki/ARM_architecture_family";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Architecture",
+                "type": "option",
+                "value": ["ARM (32-bit)", "ARM64 (AArch64)"]
+            },
+            {
+                "name": "Mode",
+                "type": "option",
+                "value": ["ARM", "Thumb", "Thumb + Cortex-M", "ARMv8"]
+            },
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": ["Little Endian", "Big Endian"]
+            },
+            {
+                "name": "Starting address (hex)",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Show instruction hex",
+                "type": "boolean",
+                "value": true
+            },
+            {
+                "name": "Show instruction position",
+                "type": "boolean",
+                "value": true
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [
+            architecture,
+            mode,
+            endianness,
+            startAddress,
+            showHex,
+            showPosition
+        ] = args;
+
+        // Remove whitespace from input
+        const hexInput = input.replace(/\s/g, "");
+
+        // Validate hex input
+        if (!/^[0-9a-fA-F]*$/.test(hexInput)) {
+            throw new OperationError("Invalid hexadecimal input. Please provide valid hex characters only.");
+        }
+
+        if (hexInput.length === 0) {
+            return "";
+        }
+
+        if (hexInput.length % 2 !== 0) {
+            throw new OperationError("Invalid hexadecimal input. Length must be even.");
+        }
+
+        // Convert hex string to byte array
+        const bytes = [];
+        for (let i = 0; i < hexInput.length; i += 2) {
+            bytes.push(parseInt(hexInput.substr(i, 2), 16));
+        }
+
+        // Determine architecture constant
+        let arch;
+        if (architecture === "ARM64 (AArch64)") {
+            arch = cs.ARCH_ARM64;
+        } else {
+            arch = cs.ARCH_ARM;
+        }
+
+        // Determine mode constant
+        let modeValue = cs.MODE_LITTLE_ENDIAN;
+
+        if (architecture === "ARM (32-bit)") {
+            switch (mode) {
+                case "ARM":
+                    modeValue = cs.MODE_ARM;
+                    break;
+                case "Thumb":
+                    modeValue = cs.MODE_THUMB;
+                    break;
+                case "Thumb + Cortex-M":
+                    modeValue = cs.MODE_THUMB | cs.MODE_MCLASS;
+                    break;
+                case "ARMv8":
+                    modeValue = cs.MODE_ARM | cs.MODE_V8;
+                    break;
+                default:
+                    modeValue = cs.MODE_ARM;
+            }
+        } else {
+            // ARM64 only has one mode (ARM mode is default for ARM64)
+            modeValue = cs.MODE_ARM;
+        }
+
+        // Add endianness
+        if (endianness === "Big Endian") {
+            modeValue |= cs.MODE_BIG_ENDIAN;
+        }
+
+        if (isWorkerEnvironment()) {
+            self.sendStatusMessage("Disassembling...");
+        }
+
+        let disassembler;
+        try {
+            disassembler = new cs.Capstone(arch, modeValue);
+        } catch (e) {
+            throw new OperationError(`Failed to initialise Capstone disassembler: ${e}`);
+        }
+
+        let instructions;
+        try {
+            instructions = disassembler.disasm(bytes, startAddress);
+        } catch (e) {
+            disassembler.close();
+            // Check if it's a "no valid instructions" error (code 0 means OK but nothing decoded)
+            if (e && e.includes && e.includes("code 0:")) {
+                throw new OperationError(`No valid ${architecture} instructions found in input. The bytes may be for a different architecture or mode.`);
+            }
+            throw new OperationError(`Disassembly failed: ${e}`);
+        }
+
+        // Format output
+        const output = [];
+        for (const insn of instructions) {
+            let line = "";
+
+            if (showPosition) {
+                // Format address as hex with 0x prefix
+                const addrHex = "0x" + insn.address.toString(16).padStart(8, "0");
+                line += addrHex + "  ";
+            }
+
+            if (showHex) {
+                // Format instruction bytes as hex
+                const bytesHex = insn.bytes.map(b => b.toString(16).padStart(2, "0")).join("");
+                line += bytesHex.padEnd(16, " ") + "  ";
+            }
+
+            line += insn.mnemonic;
+            if (insn.op_str) {
+                line += " " + insn.op_str;
+            }
+
+            output.push(line);
+        }
+
+        disassembler.close();
+
+        return output.join("\n");
+    }
+
+}
+
+export default DisassembleARM;

package/src/core/operations/DitherImage.mjs

@@ -9,13 +9,12 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Image Dither operation
  */
 class DitherImage extends Operation {
-
     /**
      * DitherImage constructor
      */
@@ -51,17 +50,19 @@ class DitherImage extends Operation {
         try {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Applying dither to image...");
-            image.dither565();
+            image.dither();
 
             let imageBuffer;
-            if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+            if (image.mime === "image/gif") {
+                imageBuffer = await image.getBuffer(JimpMime.png);
             } else {
-                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
+                imageBuffer = await image.getBuffer(image.mime);
             }
             return imageBuffer.buffer;
         } catch (err) {
-            throw new OperationError(`Error applying dither to image. (${err})`);
+            throw new OperationError(
+                `Error applying dither to image. (${err})`,
+            );
         }
     }
 
@@ -81,7 +82,6 @@ class DitherImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default DitherImage;