cyberchef 10.22.1 → 10.24.0

package/src/core/operations/ResizeImage.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, ResizeStrategy } from "jimp";
 
 /**
  * Resize Image operation
  */
 class ResizeImage extends Operation {
-
     /**
      * ResizeImage constructor
      */
@@ -24,7 +23,8 @@ class ResizeImage extends Operation {
 
         this.name = "Resize Image";
         this.module = "Image";
-        this.description = "Resizes an image to the specified width and height values.";
+        this.description =
+            "Resizes an image to the specified width and height values.";
         this.infoURL = "https://wikipedia.org/wiki/Image_scaling";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -34,23 +34,23 @@ class ResizeImage extends Operation {
                 name: "Width",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Height",
                 type: "number",
                 value: 100,
-                min: 1
+                min: 1,
             },
             {
                 name: "Unit type",
                 type: "option",
-                value: ["Pixels", "Percent"]
+                value: ["Pixels", "Percent"],
             },
             {
                 name: "Maintain aspect ratio",
                 type: "boolean",
-                value: false
+                value: false,
             },
             {
                 name: "Resizing algorithm",
@@ -60,10 +60,10 @@ class ResizeImage extends Operation {
                     "Bilinear",
                     "Bicubic",
                     "Hermite",
-                    "Bezier"
+                    "Bezier",
                 ],
-                defaultIndex: 1
-            }
+                defaultIndex: 1,
+            },
         ];
     }
 
@@ -80,11 +80,11 @@ class ResizeImage extends Operation {
             resizeAlg = args[4];
 
         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,
         };
 
         if (!isImage(input)) {
@@ -99,23 +99,31 @@ class ResizeImage extends Operation {
         }
         try {
             if (unit === "Percent") {
-                width = image.getWidth() * (width / 100);
-                height = image.getHeight() * (height / 100);
+                width = image.width * (width / 100);
+                height = image.height * (height / 100);
             }
 
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Resizing image...");
             if (aspect) {
-                image.scaleToFit(width, height, resizeMap[resizeAlg]);
+                image.scaleToFit({
+                    w: width,
+                    h: height,
+                    mode: resizeMap[resizeAlg],
+                });
             } else {
-                image.resize(width, height, resizeMap[resizeAlg]);
+                image.resize({
+                    w: width,
+                    h: height,
+                    mode: resizeMap[resizeAlg],
+                });
             }
 
             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) {
@@ -139,7 +147,6 @@ class ResizeImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ResizeImage;

package/src/core/operations/RotateImage.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";
 
 /**
  * Rotate Image operation
  */
 class RotateImage extends Operation {
-
     /**
      * RotateImage constructor
      */
@@ -24,7 +23,8 @@ class RotateImage extends Operation {
 
         this.name = "Rotate Image";
         this.module = "Image";
-        this.description = "Rotates an image by the specified number of degrees.";
+        this.description =
+            "Rotates an image by the specified number of degrees.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -33,8 +33,8 @@ class RotateImage extends Operation {
             {
                 name: "Rotation amount (degrees)",
                 type: "number",
-                value: 90
-            }
+                value: 90,
+            },
         ];
     }
 
@@ -62,10 +62,10 @@ class RotateImage extends Operation {
             image.rotate(degrees);
 
             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) {
@@ -89,7 +89,6 @@ class RotateImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default RotateImage;

package/src/core/operations/SQLBeautify.mjs

@@ -3,8 +3,7 @@
  * @copyright Crown Copyright 2016
  * @license Apache-2.0
  */
-
-import vkbeautify from "vkbeautify";
+import { format } from "sql-formatter";
 import Operation from "../Operation.mjs";
 
 /**
@@ -39,7 +38,26 @@ class SQLBeautify extends Operation {
      */
     run(input, args) {
         const indentStr = args[0];
-        return vkbeautify.sql(input, indentStr);
+        // Extract and replace bind variables like :Bind1 with __BIND_0__
+        const bindRegex = /:\w+/g;
+        const bindMap = {};
+        let bindCounter=0;
+        const placeholderInput = input.replace(bindRegex, (match) => {
+            const placeholder = `__BIND_${bindCounter++}__`;
+            bindMap[placeholder] = match;
+            return placeholder;
+        });
+        // Format the SQL with chosen options
+        let formatted= format(placeholderInput, {
+            language: "mysql", // Use MySQL as the default dialect for better compatibility with real-world SQL
+            useTabs: indentStr==="\t", // true if tab, false if spaces
+            tabWidth: indentStr.length || 4,     // fallback if empty
+            indentStyle: "standard"              // fine for most SQL
+        });
+        // Replace placeholders back with original bind variables
+        formatted = formatted.replace(/__BIND_\d+__/g, match => bindMap[match] || match);
+
+        return formatted;
     }
 
 }

package/src/core/operations/SharpenImage.mjs

@@ -8,15 +8,13 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import { gaussianBlur } from "../lib/ImageManipulation.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import Jimp from "jimp/es/index.js";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Sharpen Image operation
  */
 class SharpenImage extends Operation {
-
     /**
      * SharpenImage constructor
      */
@@ -35,22 +33,22 @@ class SharpenImage extends Operation {
                 name: "Radius",
                 type: "number",
                 value: 2,
-                min: 1
+                min: 1,
             },
             {
                 name: "Amount",
                 type: "number",
                 value: 1,
                 min: 0,
-                step: 0.1
+                step: 0.1,
             },
             {
                 name: "Threshold",
                 type: "number",
                 value: 10,
                 min: 0,
-                max: 100
-            }
+                max: 100,
+            },
         ];
     }
 
@@ -79,67 +77,102 @@ class SharpenImage extends Operation {
             const blurMask = image.clone();
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Blurring cloned image)");
-            const blurImage = gaussianBlur(image.clone(), radius);
-
+                self.sendStatusMessage(
+                    "Sharpening image... (Blurring cloned image)",
+                );
+            const blurImage = image.clone().gaussian(radius);
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Creating unsharp mask)");
-            blurMask.scan(0, 0, blurMask.bitmap.width, blurMask.bitmap.height, function(x, y, idx) {
-                const blurRed = blurImage.bitmap.data[idx];
-                const blurGreen = blurImage.bitmap.data[idx + 1];
-                const blurBlue = blurImage.bitmap.data[idx + 2];
-
-                const normalRed = this.bitmap.data[idx];
-                const normalGreen = this.bitmap.data[idx + 1];
-                const normalBlue = this.bitmap.data[idx + 2];
-
-                // Subtract blurred pixel value from normal image
-                this.bitmap.data[idx] = (normalRed > blurRed) ? normalRed - blurRed : 0;
-                this.bitmap.data[idx + 1] = (normalGreen > blurGreen) ? normalGreen - blurGreen : 0;
-                this.bitmap.data[idx + 2] = (normalBlue > blurBlue) ? normalBlue - blurBlue : 0;
-            });
+                self.sendStatusMessage(
+                    "Sharpening image... (Creating unsharp mask)",
+                );
+            blurMask.scan(
+                0,
+                0,
+                blurMask.bitmap.width,
+                blurMask.bitmap.height,
+                function (x, y, idx) {
+                    const blurRed = blurImage.bitmap.data[idx];
+                    const blurGreen = blurImage.bitmap.data[idx + 1];
+                    const blurBlue = blurImage.bitmap.data[idx + 2];
+
+                    const normalRed = this.bitmap.data[idx];
+                    const normalGreen = this.bitmap.data[idx + 1];
+                    const normalBlue = this.bitmap.data[idx + 2];
+
+                    // Subtract blurred pixel value from normal image
+                    this.bitmap.data[idx] =
+                        normalRed > blurRed ? normalRed - blurRed : 0;
+                    this.bitmap.data[idx + 1] =
+                        normalGreen > blurGreen ? normalGreen - blurGreen : 0;
+                    this.bitmap.data[idx + 2] =
+                        normalBlue > blurBlue ? normalBlue - blurBlue : 0;
+                },
+            );
 
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Sharpening image... (Merging with unsharp mask)");
-            image.scan(0, 0, image.bitmap.width, image.bitmap.height, function(x, y, idx) {
-                let maskRed = blurMask.bitmap.data[idx];
-                let maskGreen = blurMask.bitmap.data[idx + 1];
-                let maskBlue = blurMask.bitmap.data[idx + 2];
-
-                const normalRed = this.bitmap.data[idx];
-                const normalGreen = this.bitmap.data[idx + 1];
-                const normalBlue = this.bitmap.data[idx + 2];
-
-                // Calculate luminance
-                const maskLuminance = (0.2126 * maskRed + 0.7152 * maskGreen + 0.0722 * maskBlue);
-                const normalLuminance = (0.2126 * normalRed + 0.7152 * normalGreen + 0.0722 * normalBlue);
-
-                let luminanceDiff;
-                if (maskLuminance > normalLuminance) {
-                    luminanceDiff = maskLuminance - normalLuminance;
-                } else {
-                    luminanceDiff = normalLuminance - maskLuminance;
-                }
-
-                // Scale mask colours by amount
-                maskRed = maskRed * amount;
-                maskGreen = maskGreen * amount;
-                maskBlue = maskBlue * amount;
-
-                // Only change pixel value if the difference is higher than threshold
-                if ((luminanceDiff / 255) * 100 >= threshold) {
-                    this.bitmap.data[idx] = (normalRed + maskRed) <= 255 ? normalRed + maskRed : 255;
-                    this.bitmap.data[idx + 1] = (normalGreen + maskGreen) <= 255 ? normalGreen + maskGreen : 255;
-                    this.bitmap.data[idx + 2] = (normalBlue + maskBlue) <= 255 ? normalBlue + maskBlue : 255;
-                }
-            });
+                self.sendStatusMessage(
+                    "Sharpening image... (Merging with unsharp mask)",
+                );
+            image.scan(
+                0,
+                0,
+                image.bitmap.width,
+                image.bitmap.height,
+                function (x, y, idx) {
+                    let maskRed = blurMask.bitmap.data[idx];
+                    let maskGreen = blurMask.bitmap.data[idx + 1];
+                    let maskBlue = blurMask.bitmap.data[idx + 2];
+
+                    const normalRed = this.bitmap.data[idx];
+                    const normalGreen = this.bitmap.data[idx + 1];
+                    const normalBlue = this.bitmap.data[idx + 2];
+
+                    // Calculate luminance
+                    const maskLuminance =
+                        0.2126 * maskRed +
+                        0.7152 * maskGreen +
+                        0.0722 * maskBlue;
+                    const normalLuminance =
+                        0.2126 * normalRed +
+                        0.7152 * normalGreen +
+                        0.0722 * normalBlue;
+
+                    let luminanceDiff;
+                    if (maskLuminance > normalLuminance) {
+                        luminanceDiff = maskLuminance - normalLuminance;
+                    } else {
+                        luminanceDiff = normalLuminance - maskLuminance;
+                    }
+
+                    // Scale mask colours by amount
+                    maskRed = maskRed * amount;
+                    maskGreen = maskGreen * amount;
+                    maskBlue = maskBlue * amount;
+
+                    // Only change pixel value if the difference is higher than threshold
+                    if ((luminanceDiff / 255) * 100 >= threshold) {
+                        this.bitmap.data[idx] =
+                            normalRed + maskRed <= 255 ?
+                                normalRed + maskRed :
+                                255;
+                        this.bitmap.data[idx + 1] =
+                            normalGreen + maskGreen <= 255 ?
+                                normalGreen + maskGreen :
+                                255;
+                        this.bitmap.data[idx + 2] =
+                            normalBlue + maskBlue <= 255 ?
+                                normalBlue + maskBlue :
+                                255;
+                    }
+                },
+            );
 
             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) {
@@ -163,7 +196,6 @@ class SharpenImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default SharpenImage;

package/src/core/operations/SplitColourChannels.mjs

@@ -7,14 +7,13 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.mjs";
-import {isImage} from "../lib/FileType.mjs";
-import Jimp from "jimp/es/index.js";
+import { isImage } from "../lib/FileType.mjs";
+import { Jimp, JimpMime } from "jimp";
 
 /**
  * Split Colour Channels operation
  */
 class SplitColourChannels extends Operation {
-
     /**
      * SplitColourChannels constructor
      */
@@ -23,7 +22,8 @@ class SplitColourChannels extends Operation {
 
         this.name = "Split Colour Channels";
         this.module = "Image";
-        this.description = "Splits the given image into its red, green and blue colour channels.";
+        this.description =
+            "Splits the given image into its red, green and blue colour channels.";
         this.infoURL = "https://wikipedia.org/wiki/Channel_(digital_image)";
         this.inputType = "ArrayBuffer";
         this.outputType = "List<File>";
@@ -48,26 +48,44 @@ class SplitColourChannels extends Operation {
                 const split = parsedImage
                     .clone()
                     .color([
-                        {apply: "blue", params: [-255]},
-                        {apply: "green", params: [-255]}
+                        { apply: "blue", params: [-255] },
+                        { apply: "green", params: [-255] },
                     ])
-                    .getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "red.png", {type: "image/png"}));
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "red.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split red channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split red channel: ${err}`),
+                );
             }
         });
 
         const green = new Promise(async (resolve, reject) => {
             try {
-                const split = parsedImage.clone()
+                const split = parsedImage
+                    .clone()
                     .color([
-                        {apply: "red", params: [-255]},
-                        {apply: "blue", params: [-255]},
-                    ]).getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "green.png", {type: "image/png"}));
+                        { apply: "red", params: [-255] },
+                        { apply: "blue", params: [-255] },
+                    ])
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "green.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split green channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split green channel: ${err}`),
+                );
             }
         });
 
@@ -75,12 +93,21 @@ class SplitColourChannels extends Operation {
             try {
                 const split = parsedImage
                     .color([
-                        {apply: "red", params: [-255]},
-                        {apply: "green", params: [-255]},
-                    ]).getBufferAsync(Jimp.MIME_PNG);
-                resolve(new File([new Uint8Array((await split).values())], "blue.png", {type: "image/png"}));
+                        { apply: "red", params: [-255] },
+                        { apply: "green", params: [-255] },
+                    ])
+                    .getBuffer(JimpMime.png);
+                resolve(
+                    new File(
+                        [new Uint8Array((await split).values())],
+                        "blue.png",
+                        { type: "image/png" },
+                    ),
+                );
             } catch (err) {
-                reject(new OperationError(`Could not split blue channel: ${err}`));
+                reject(
+                    new OperationError(`Could not split blue channel: ${err}`),
+                );
             }
         });
 
@@ -96,7 +123,6 @@ class SplitColourChannels extends Operation {
     async present(files) {
         return await Utils.displayFilesAsHTML(files);
     }
-
 }
 
 export default SplitColourChannels;

package/src/core/operations/TextIntegerConverter.mjs

@@ -0,0 +1,123 @@
+/**
+ * @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";
+
+/* ---------- helper functions ---------- */
+
+/**
+ * Convert text to BigInt (big-endian byte interpretation)
+ */
+function textToBigInt(text) {
+    if (text.length === 0) return 0n;
+
+    let result = 0n;
+    for (let i = 0; i < text.length; i++) {
+        const charCode = BigInt(text.charCodeAt(i));
+        if (charCode > 255n) {
+            throw new OperationError(
+                `Character at position ${i} exceeds Latin-1 range (0-255).\n` +
+                "Only ASCII and Latin-1 characters are supported.");
+        }
+        result = (result << 8n) | charCode;
+    }
+    return result;
+}
+
+/**
+ * Convert BigInt to text (big-endian byte interpretation)
+ */
+function bigIntToText(value) {
+    if (value === 0n) return "";
+
+    const bytes = [];
+    let num = value;
+
+    while (num > 0n) {
+        bytes.unshift(Number(num & 0xFFn));
+        num >>= 8n;
+    }
+
+    return String.fromCharCode(...bytes);
+}
+
+/* ---------- operation class ---------- */
+
+/**
+ * Text/Integer Converter operation
+ */
+class TextIntegerConverter extends Operation {
+    /**
+     * TextIntegerConverter constructor
+     */
+    constructor() {
+        super();
+
+        this.description =
+            "Converts between text strings and large integers (decimal or hexadecimal).<br><br>" +
+            "Text is interpreted as a big-endian sequence of character codes. For example:<br>" +
+            "ABC is 0x414243 (hex) is 4276803 (decimal)<br>" +
+            "<b>Input format detection:</b><br>" +
+            "Decimal: digits 0-9 only<br>" +
+            "Hexadecimal: 0x... prefix<br>" +
+            "Quoted or unquoted text: treated as string<br><br>" +
+            "<b>Character limitations:</b><br>" +
+            "Text input may only contain ASCII and Latin-1 characters (code point < 256).<br>" +
+            "Multi-byte Unicode characters will generate an error.<br><br>." ;
+        this.infoURL = "https://wikipedia.org/wiki/Endianness";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Output format",
+                type: "option",
+                value: ["String", "Decimal", "Hexadecimal"]
+            }
+        ];
+        this.name = "Text-Integer Conversion";
+        this.module = "Default";
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const outputFormat = args[0];
+        const trimmed = input.trim();
+
+        let bigIntValue;
+
+        if (!trimmed) {
+            // Null input - treat as zero
+            bigIntValue = 0;
+        } else if (/^0x[0-9a-f]+$/i.test(trimmed) ||
+            /^[+-]?[0-9]+$/.test(trimmed)) {
+            // Hex or decimal integer
+            bigIntValue = BigInt(trimmed);
+        } else if (/^["'].*["']$/.test(trimmed)) {
+            // Quoted string: Remove quotes and convert text to BigInt
+            const text = trimmed.slice(1, -1);
+            bigIntValue = textToBigInt(text);
+        } else {
+            // Assume it's unquoted text
+            bigIntValue = textToBigInt(trimmed);
+        }
+
+        // Convert to output format
+        if (outputFormat === "String") {
+            return bigIntToText(bigIntValue);
+        } else if (outputFormat === "Decimal") {
+            return bigIntValue.toString();
+        } else { // Hexadecimal
+            return "0x" + bigIntValue.toString(16);
+        }
+    }
+}
+
+export default TextIntegerConverter;