cyberchef 10.22.1 → 10.24.0

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;

package/src/core/operations/FlipImage.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";
 
 /**
  * Flip Image operation
  */
 class FlipImage extends Operation {
-
     /**
      * FlipImage constructor
      */
@@ -33,8 +32,8 @@ class FlipImage extends Operation {
             {
                 name: "Axis",
                 type: "option",
-                value: ["Horizontal", "Vertical"]
-            }
+                value: ["Horizontal", "Vertical"],
+            },
         ];
     }
 
@@ -60,18 +59,24 @@ class FlipImage extends Operation {
                 self.sendStatusMessage("Flipping image...");
             switch (flipAxis) {
                 case "Horizontal":
-                    image.flip(true, false);
+                    image.flip({
+                        horizontal: true,
+                        vertical: false,
+                    });
                     break;
                 case "Vertical":
-                    image.flip(false, true);
+                    image.flip({
+                        horizontal: false,
+                        vertical: true,
+                    });
                     break;
             }
 
             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) {
@@ -95,7 +100,6 @@ class FlipImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default FlipImage;

package/src/core/operations/GenerateImage.mjs

@@ -7,16 +7,15 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.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 { isImage } from "../lib/FileType.mjs";
+import { toBase64 } from "../lib/Base64.mjs";
+import { isWorkerEnvironment } from "../Utils.mjs";
+import { Jimp, JimpMime, ResizeStrategy, rgbaToInt } from "jimp";
 
 /**
  * Generate Image operation
  */
 class GenerateImage extends Operation {
-
     /**
      * GenerateImage constructor
      */
@@ -25,27 +24,28 @@ class GenerateImage extends Operation {
 
         this.name = "Generate Image";
         this.module = "Image";
-        this.description = "Generates an image using the input as pixel values.";
+        this.description =
+            "Generates an image using the input as pixel values.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
         this.presentType = "html";
         this.args = [
             {
-                "name": "Mode",
-                "type": "option",
-                "value": ["Greyscale", "RG", "RGB", "RGBA", "Bits"]
+                name: "Mode",
+                type: "option",
+                value: ["Greyscale", "RG", "RGB", "RGBA", "Bits"],
             },
             {
-                "name": "Pixel Scale Factor",
-                "type": "number",
-                "value": 8,
+                name: "Pixel Scale Factor",
+                type: "number",
+                value: 8,
             },
             {
-                "name": "Pixels per row",
-                "type": "number",
-                "value": 64,
-            }
+                name: "Pixels per row",
+                type: "number",
+                value: 64,
+            },
         ];
     }
 
@@ -67,21 +67,23 @@ class GenerateImage extends Operation {
         }
 
         const bytePerPixelMap = {
-            "Greyscale": 1,
-            "RG": 2,
-            "RGB": 3,
-            "RGBA": 4,
-            "Bits": 1/8,
+            Greyscale: 1,
+            RG: 2,
+            RGB: 3,
+            RGBA: 4,
+            Bits: 1 / 8,
         };
 
         const bytesPerPixel = bytePerPixelMap[mode];
 
-        if (bytesPerPixel > 0 && input.length % bytesPerPixel  !== 0) {
-            throw new OperationError(`Number of bytes is not a divisor of ${bytesPerPixel}`);
+        if (bytesPerPixel > 0 && input.length % bytesPerPixel !== 0) {
+            throw new OperationError(
+                `Number of bytes is not a divisor of ${bytesPerPixel}`,
+            );
         }
 
         const height = Math.ceil(input.length / bytesPerPixel / width);
-        const image = await new Jimp(width, height, (err, image) => {});
+        const image = new Jimp({ width, height });
 
         if (isWorkerEnvironment())
             self.sendStatusMessage("Generating image from data...");
@@ -94,8 +96,8 @@ class GenerateImage extends Operation {
                     const x = index % width;
                     const y = Math.floor(index / width);
 
-                    const value = curByte[k] === "0" ? 0xFF : 0x00;
-                    const pixel = Jimp.rgbaToInt(value, value, value, 0xFF);
+                    const value = curByte[k] === "0" ? 0xff : 0x00;
+                    const pixel = rgbaToInt(value, value, value, 0xff);
                     image.setPixelColor(pixel, x, y);
                 }
             }
@@ -109,7 +111,7 @@ class GenerateImage extends Operation {
                 let red = 0x00;
                 let green = 0x00;
                 let blue = 0x00;
-                let alpha = 0xFF;
+                let alpha = 0xff;
 
                 switch (mode) {
                     case "Greyscale":
@@ -139,10 +141,12 @@ class GenerateImage extends Operation {
                 }
 
                 try {
-                    const pixel = Jimp.rgbaToInt(red, green, blue, alpha);
+                    const pixel = rgbaToInt(red, green, blue, alpha);
                     image.setPixelColor(pixel, x, y);
                 } catch (err) {
-                    throw new OperationError(`Error while generating image from pixel values. (${err})`);
+                    throw new OperationError(
+                        `Error while generating image from pixel values. (${err})`,
+                    );
                 }
             }
         }
@@ -151,11 +155,15 @@ class GenerateImage extends Operation {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Scaling image...");
 
-            image.scaleToFit(width*scale, height*scale, Jimp.RESIZE_NEAREST_NEIGHBOR);
+            image.scaleToFit({
+                w: width * scale,
+                h: height * scale,
+                mode: ResizeStrategy.NEAREST_NEIGHBOR,
+            });
         }
 
         try {
-            const imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
+            const imageBuffer = await image.getBuffer(JimpMime.png);
             return imageBuffer.buffer;
         } catch (err) {
             throw new OperationError(`Error generating image. (${err})`);
@@ -178,7 +186,6 @@ class GenerateImage extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default GenerateImage;

package/src/core/operations/ImageBrightnessContrast.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 Brightness / Contrast operation
  */
 class ImageBrightnessContrast extends Operation {
-
     /**
      * ImageBrightnessContrast constructor
      */
@@ -35,15 +34,15 @@ class ImageBrightnessContrast extends Operation {
                 type: "number",
                 value: 0,
                 min: -100,
-                max: 100
+                max: 100,
             },
             {
                 name: "Contrast",
                 type: "number",
                 value: 0,
                 min: -100,
-                max: 100
-            }
+                max: 100,
+            },
         ];
     }
 
@@ -77,14 +76,16 @@ class ImageBrightnessContrast extends Operation {
             }
 
             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 adjusting image brightness or contrast. (${err})`);
+            throw new OperationError(
+                `Error adjusting image brightness or contrast. (${err})`,
+            );
         }
     }
 
@@ -104,7 +105,6 @@ class ImageBrightnessContrast extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ImageBrightnessContrast;

package/src/core/operations/ImageFilter.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 Filter operation
  */
 class ImageFilter extends Operation {
-
     /**
      * ImageFilter constructor
      */
@@ -33,11 +32,8 @@ class ImageFilter extends Operation {
             {
                 name: "Filter type",
                 type: "option",
-                value: [
-                    "Greyscale",
-                    "Sepia"
-                ]
-            }
+                value: ["Greyscale", "Sepia"],
+            },
         ];
     }
 
@@ -60,7 +56,11 @@ class ImageFilter extends Operation {
         }
         try {
             if (isWorkerEnvironment())
-                self.sendStatusMessage("Applying " + filterType.toLowerCase() + " filter to image...");
+                self.sendStatusMessage(
+                    "Applying " +
+                        filterType.toLowerCase() +
+                        " filter to image...",
+                );
             if (filterType === "Greyscale") {
                 image.greyscale();
             } else {
@@ -68,14 +68,16 @@ class ImageFilter extends Operation {
             }
 
             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 filter to image. (${err})`);
+            throw new OperationError(
+                `Error applying filter to image. (${err})`,
+            );
         }
     }
 
@@ -95,7 +97,6 @@ class ImageFilter extends Operation {
 
         return `<img src="data:${type};base64,${toBase64(dataArray)}">`;
     }
-
 }
 
 export default ImageFilter;

package/src/core/operations/ImageHueSaturationLightness.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 Hue/Saturation/Lightness operation
  */
 class ImageHueSaturationLightness extends Operation {
-
     /**
      * ImageHueSaturationLightness constructor
      */
@@ -24,7 +23,8 @@ class ImageHueSaturationLightness extends Operation {
 
         this.name = "Image Hue/Saturation/Lightness";
         this.module = "Image";
-        this.description = "Adjusts the hue / saturation / lightness (HSL) values of an image.";
+        this.description =
+            "Adjusts the hue / saturation / lightness (HSL) values of an image.";
         this.infoURL = "";
         this.inputType = "ArrayBuffer";
         this.outputType = "ArrayBuffer";
@@ -35,22 +35,22 @@ class ImageHueSaturationLightness extends Operation {
                 type: "number",
                 value: 0,
                 min: -360,
-                max: 360
+                max: 360,
             },
             {
                 name: "Saturation",
                 type: "number",
                 value: 0,
                 min: -100,
-                max: 100
+                max: 100,
             },
             {
                 name: "Lightness",
                 type: "number",
                 value: 0,
                 min: -100,
-                max: 100
-            }
+                max: 100,
+            },
         ];
     }
 
@@ -76,43 +76,45 @@ class ImageHueSaturationLightness extends Operation {
             if (hue !== 0) {
                 if (isWorkerEnvironment())
                     self.sendStatusMessage("Changing image hue...");
-                image.colour([
+                image.color([
                     {
                         apply: "hue",
-                        params: [hue]
-                    }
+                        params: [hue],
+                    },
                 ]);
             }
             if (saturation !== 0) {
                 if (isWorkerEnvironment())
                     self.sendStatusMessage("Changing image saturation...");
-                image.colour([
+                image.color([
                     {
                         apply: "saturate",
-                        params: [saturation]
-                    }
+                        params: [saturation],
+                    },
                 ]);
             }
             if (lightness !== 0) {
                 if (isWorkerEnvironment())
                     self.sendStatusMessage("Changing image lightness...");
-                image.colour([
+                image.color([
                     {
                         apply: "lighten",
-                        params: [lightness]
-                    }
+                        params: [lightness],
+                    },
                 ]);
             }
 
             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 adjusting image hue / saturation / lightness. (${err})`);
+            throw new OperationError(
+                `Error adjusting image hue / saturation / lightness. (${err})`,
+            );
         }
     }