Merged master and followed naming convention updates

src/core/operations/AESDecrypt.mjs

@@ -112,7 +112,7 @@ class AESDecrypt extends Operation {
     run(input, args) {
         const key = Utils.convertToByteString(args[0].string, args[0].option),
             iv = Utils.convertToByteString(args[1].string, args[1].option),
-            mode = args[2].substring(0, 3),
+            mode = args[2].split("/")[0],
             noPadding = args[2].endsWith("NoPadding"),
             inputType = args[3],
             outputType = args[4],

src/core/operations/AESEncrypt.mjs

@@ -66,6 +66,14 @@ class AESEncrypt extends Operation {
                     {
                         name: "ECB",
                         off: [5]
+                    },
+                    {
+                        name: "CBC/NoPadding",
+                        off: [5]
+                    },
+                    {
+                        name: "ECB/NoPadding",
+                        off: [5]
                     }
                 ]
             },
@@ -98,7 +106,8 @@ class AESEncrypt extends Operation {
     run(input, args) {
         const key = Utils.convertToByteString(args[0].string, args[0].option),
             iv = Utils.convertToByteString(args[1].string, args[1].option),
-            mode = args[2],
+            mode = args[2].split("/")[0],
+            noPadding =  args[2].endsWith("NoPadding"),
             inputType = args[3],
             outputType = args[4],
             aad = Utils.convertToByteString(args[5].string, args[5].option);
@@ -114,11 +123,20 @@ The following algorithms will be used based on the size of the key:
 
         input = Utils.convertToByteString(input, inputType);
 
+        // Handle NoPadding modes
+        if (noPadding && input.length % 16 !== 0) {
+            throw new OperationError("Input length must be a multiple of 16 bytes for NoPadding modes.");
+        }
         const cipher = forge.cipher.createCipher("AES-" + mode, key);
         cipher.start({
             iv: iv,
             additionalData: mode === "GCM" ? aad : undefined
         });
+        if (noPadding) {
+            cipher.mode.pad = function(output, options) {
+                return true;
+            };
+        }
         cipher.update(forge.util.createBuffer(input));
         cipher.finish();
 

src/core/operations/AddLineNumbers.mjs

@@ -22,7 +22,13 @@ class AddLineNumbers extends Operation {
         this.description = "Adds line numbers to the output.";
         this.inputType = "string";
         this.outputType = "string";
-        this.args = [];
+        this.args = [
+            {
+                "name": "Offset",
+                "type": "number",
+                "value": 0
+            }
+        ];
     }
 
     /**
@@ -33,10 +39,11 @@ class AddLineNumbers extends Operation {
     run(input, args) {
         const lines = input.split("\n"),
             width = lines.length.toString().length;
+        const offset = args[0] ? parseInt(args[0], 10) : 0;
         let output = "";
 
         for (let n = 0; n < lines.length; n++) {
-            output += (n+1).toString().padStart(width, " ") + " " + lines[n] + "\n";
+            output += (n+1+offset).toString().padStart(width, " ") + " " + lines[n] + "\n";
         }
         return output.slice(0, output.length-1);
     }

src/core/operations/AddTextToImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Add Text To Image operation
@@ -128,7 +127,7 @@ class AddTextToImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -164,7 +163,7 @@ class AddTextToImage extends Operation {
             const font = fontsMap[fontFace];
 
             // LoadFont needs an absolute url, so append the font name to self.docURL
-            const jimpFont = await jimp.loadFont(self.docURL + "/" + font.default);
+            const jimpFont = await Jimp.loadFont(self.docURL + "/" + font.default);
 
             jimpFont.pages.forEach(function(page) {
                 if (page.bitmap) {
@@ -191,7 +190,7 @@ class AddTextToImage extends Operation {
             });
 
             // Create a temporary image to hold the rendered text
-            const textImage = new jimp(jimp.measureText(jimpFont, text), jimp.measureTextHeight(jimpFont, text));
+            const textImage = new Jimp(Jimp.measureText(jimpFont, text), Jimp.measureTextHeight(jimpFont, text));
             textImage.print(jimpFont, 0, 0, text);
 
             // Scale the rendered text image to the correct size
@@ -199,9 +198,9 @@ class AddTextToImage extends Operation {
             if (size !== 1) {
                 // Use bicubic for decreasing size
                 if (size > 1) {
-                    textImage.scale(scaleFactor, jimp.RESIZE_BICUBIC);
+                    textImage.scale(scaleFactor, Jimp.RESIZE_BICUBIC);
                 } else {
-                    textImage.scale(scaleFactor, jimp.RESIZE_BILINEAR);
+                    textImage.scale(scaleFactor, Jimp.RESIZE_BILINEAR);
                 }
             }
 
@@ -235,9 +234,9 @@ class AddTextToImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/Argon2.mjs

@@ -0,0 +1,117 @@
+/**
+ * @author Tan Zhen Yong [tzy@beyondthesprawl.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import argon2 from "argon2-browser";
+
+/**
+ * Argon2 operation
+ */
+class Argon2 extends Operation {
+
+    /**
+     * Argon2 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Argon2";
+        this.module = "Crypto";
+        this.description = "Argon2 is a key derivation function that was selected as the winner of the Password Hashing Competition in July 2015. It was designed by Alex Biryukov, Daniel Dinu, and Dmitry Khovratovich from the University of Luxembourg.<br><br>Enter the password in the input to generate its hash.";
+        this.infoURL = "https://wikipedia.org/wiki/Argon2";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Salt",
+                "type": "toggleString",
+                "value": "somesalt",
+                "toggleValues": ["UTF8", "Hex", "Base64", "Latin1"]
+            },
+            {
+                "name": "Iterations",
+                "type": "number",
+                "value": 3
+            },
+            {
+                "name": "Memory (KiB)",
+                "type": "number",
+                "value": 4096
+            },
+            {
+                "name": "Parallelism",
+                "type": "number",
+                "value": 1
+            },
+            {
+                "name": "Hash length (bytes)",
+                "type": "number",
+                "value": 32
+            },
+            {
+                "name": "Type",
+                "type": "option",
+                "value": ["Argon2i", "Argon2d", "Argon2id"],
+                "defaultIndex": 0
+            },
+            {
+                "name": "Output format",
+                "type": "option",
+                "value": ["Encoded hash", "Hex hash", "Raw hash"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const argon2Types = {
+            "Argon2i": argon2.ArgonType.Argon2i,
+            "Argon2d": argon2.ArgonType.Argon2d,
+            "Argon2id": argon2.ArgonType.Argon2id
+        };
+
+        const salt = Utils.convertToByteString(args[0].string || "", args[0].option),
+            time = args[1],
+            mem = args[2],
+            parallelism = args[3],
+            hashLen = args[4],
+            type = argon2Types[args[5]],
+            outFormat = args[6];
+
+        try {
+            const result = await argon2.hash({
+                pass: input,
+                salt,
+                time,
+                mem,
+                parallelism,
+                hashLen,
+                type,
+            });
+
+            switch (outFormat) {
+                case "Hex hash":
+                    return result.hashHex;
+                case "Raw hash":
+                    return Utils.arrayBufferToStr(result.hash);
+                case "Encoded hash":
+                default:
+                    return result.encoded;
+            }
+        } catch (err) {
+            throw new OperationError(`Error: ${err.message}`);
+        }
+    }
+
+}
+
+export default Argon2;

src/core/operations/Argon2Compare.mjs

@@ -0,0 +1,58 @@
+/**
+ * @author Tan Zhen Yong [tzy@beyondthesprawl.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import argon2 from "argon2-browser";
+
+/**
+ * Argon2 compare operation
+ */
+class Argon2Compare extends Operation {
+
+    /**
+     * Argon2Compare constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Argon2 compare";
+        this.module = "Crypto";
+        this.description = "Tests whether the input matches the given Argon2 hash. To test multiple possible passwords, use the 'Fork' operation.";
+        this.infoURL = "https://wikipedia.org/wiki/Argon2";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Encoded hash",
+                "type": "string",
+                "value": ""
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const encoded = args[0];
+
+        try {
+            await argon2.verify({
+                pass: input,
+                encoded
+            });
+
+            return `Match: ${input}`;
+        } catch (err) {
+            return "No match";
+        }
+    }
+
+}
+
+export default Argon2Compare;

src/core/operations/BlowfishDecrypt.mjs

@@ -70,10 +70,14 @@ class BlowfishDecrypt extends Operation {
             inputType = args[3],
             outputType = args[4];
 
-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
 
-Blowfish uses a key length of 8 bytes (64 bits).`);
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }
+
+        if (mode !== "ECB" && iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`);
         }
 
         input = Utils.convertToByteString(input, inputType);

src/core/operations/BlowfishEncrypt.mjs

@@ -70,10 +70,14 @@ class BlowfishEncrypt extends Operation {
             inputType = args[3],
             outputType = args[4];
 
-        if (key.length !== 8) {
+        if (key.length < 4 || key.length > 56) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
 
-Blowfish uses a key length of 8 bytes (64 bits).`);
+Blowfish's key length needs to be between 4 and 56 bytes (32-448 bits).`);
+        }
+
+        if (mode !== "ECB" && iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes. Expected 8 bytes.`);
         }
 
         input = Utils.convertToByteString(input, inputType);

src/core/operations/BlurImage.mjs

@@ -10,8 +10,7 @@ import { isWorkerEnvironment } from "../Utils.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { gaussianBlur } from "../lib/ImageManipulation.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Blur Image operation
@@ -60,7 +59,7 @@ class BlurImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -80,9 +79,9 @@ class BlurImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/CRC16Checksum.mjs

@@ -1,41 +0,0 @@
-/**
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2016
- * @license Apache-2.0
- */
-
-import Operation from "../Operation.mjs";
-import JSCRC from "js-crc";
-
-/**
- * CRC-16 Checksum operation
- */
-class CRC16Checksum extends Operation {
-
-    /**
-     * CRC16Checksum constructor
-     */
-    constructor() {
-        super();
-
-        this.name = "CRC-16 Checksum";
-        this.module = "Crypto";
-        this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961.";
-        this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
-        this.inputType = "ArrayBuffer";
-        this.outputType = "string";
-        this.args = [];
-    }
-
-    /**
-     * @param {ArrayBuffer} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    run(input, args) {
-        return JSCRC.crc16(input);
-    }
-
-}
-
-export default CRC16Checksum;

src/core/operations/CRC32Checksum.mjs

@@ -1,41 +0,0 @@
-/**
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2016
- * @license Apache-2.0
- */
-
-import Operation from "../Operation.mjs";
-import JSCRC from "js-crc";
-
-/**
- * CRC-32 Checksum operation
- */
-class CRC32Checksum extends Operation {
-
-    /**
-     * CRC32Checksum constructor
-     */
-    constructor() {
-        super();
-
-        this.name = "CRC-32 Checksum";
-        this.module = "Crypto";
-        this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961; the 32-bit CRC function of Ethernet and many other standards is the work of several researchers and was published in 1975.";
-        this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
-        this.inputType = "ArrayBuffer";
-        this.outputType = "string";
-        this.args = [];
-    }
-
-    /**
-     * @param {ArrayBuffer} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    run(input, args) {
-        return JSCRC.crc32(input);
-    }
-
-}
-
-export default CRC32Checksum;

src/core/operations/CRC8Checksum.mjs

@@ -1,157 +0,0 @@
-/**
- * @author mshwed [m@ttshwed.com]
- * @copyright Crown Copyright 2019
- * @license Apache-2.0
- */
-
-import Operation from "../Operation.mjs";
-import OperationError from "../errors/OperationError.mjs";
-
-import { toHexFast } from "../lib/Hex.mjs";
-
-/**
- * CRC-8 Checksum operation
- */
-class CRC8Checksum extends Operation {
-
-    /**
-     * CRC8Checksum constructor
-     */
-    constructor() {
-        super();
-
-        this.name = "CRC-8 Checksum";
-        this.module = "Crypto";
-        this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961.";
-        this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
-        this.inputType = "ArrayBuffer";
-        this.outputType = "string";
-        this.args = [
-            {
-                "name": "Algorithm",
-                "type": "option",
-                "value": [
-                    "CRC-8",
-                    "CRC-8/CDMA2000",
-                    "CRC-8/DARC",
-                    "CRC-8/DVB-S2",
-                    "CRC-8/EBU",
-                    "CRC-8/I-CODE",
-                    "CRC-8/ITU",
-                    "CRC-8/MAXIM",
-                    "CRC-8/ROHC",
-                    "CRC-8/WCDMA"
-                ]
-            }
-        ];
-    }
-
-    /**
-     * Generates the pre-computed lookup table for byte division
-     *
-     * @param polynomial
-     */
-    calculateCRC8LookupTable(polynomial) {
-        const crc8Table = new Uint8Array(256);
-
-        let currentByte;
-        for (let i = 0; i < 256; i++) {
-            currentByte = i;
-            for (let bit = 0; bit < 8; bit++) {
-                if ((currentByte & 0x80) !== 0) {
-                    currentByte <<= 1;
-                    currentByte ^= polynomial;
-                } else {
-                    currentByte <<= 1;
-                }
-            }
-
-            crc8Table[i] = currentByte;
-        }
-
-        return crc8Table;
-    }
-
-    /**
-     * Calculates the CRC-8 Checksum from an input
-     *
-     * @param {ArrayBuffer} input
-     * @param {number} polynomial
-     * @param {number} initializationValue
-     * @param {boolean} inputReflection
-     * @param {boolean} outputReflection
-     * @param {number} xorOut
-     */
-    calculateCRC8(input, polynomial, initializationValue, inputReflection, outputReflection, xorOut) {
-        const crcSize = 8;
-        const crcTable = this.calculateCRC8LookupTable(polynomial);
-
-        let crc = initializationValue !== 0 ? initializationValue : 0;
-        let currentByte, position;
-
-        input = new Uint8Array(input);
-        for (const inputByte of input) {
-            currentByte = inputReflection ? this.reverseBits(inputByte, crcSize) : inputByte;
-
-            position = (currentByte ^ crc) & 255;
-            crc = crcTable[position];
-        }
-
-        crc = outputReflection ? this.reverseBits(crc, crcSize) : crc;
-
-        if (xorOut !== 0) crc = crc ^ xorOut;
-
-        return toHexFast(new Uint8Array([crc]));
-    }
-
-    /**
-     * Reverse the bits for a given input byte.
-     *
-     * @param {number} input
-     */
-    reverseBits(input, hashSize) {
-        let reversedByte = 0;
-        for (let i = hashSize - 1; i >= 0; i--) {
-            reversedByte |= ((input & 1) << i);
-            input >>= 1;
-        }
-
-        return reversedByte;
-    }
-
-    /**
-     * @param {ArrayBuffer} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    run(input, args) {
-        const algorithm = args[0];
-
-        switch (algorithm) {
-            case "CRC-8":
-                return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x0);
-            case "CRC-8/CDMA2000":
-                return this.calculateCRC8(input, 0x9B, 0xFF, false, false, 0x0);
-            case "CRC-8/DARC":
-                return this.calculateCRC8(input, 0x39, 0x0, true, true, 0x0);
-            case "CRC-8/DVB-S2":
-                return this.calculateCRC8(input, 0xD5, 0x0, false, false, 0x0);
-            case "CRC-8/EBU":
-                return this.calculateCRC8(input, 0x1D, 0xFF, true, true, 0x0);
-            case "CRC-8/I-CODE":
-                return this.calculateCRC8(input, 0x1D, 0xFD, false, false, 0x0);
-            case "CRC-8/ITU":
-                return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x55);
-            case "CRC-8/MAXIM":
-                return this.calculateCRC8(input, 0x31, 0x0, true, true, 0x0);
-            case "CRC-8/ROHC":
-                return this.calculateCRC8(input, 0x7, 0xFF, true, true, 0x0);
-            case "CRC-8/WCDMA":
-                return this.calculateCRC8(input, 0x9B, 0x0, true, true, 0x0);
-            default:
-                throw new OperationError("Unknown checksum algorithm");
-        }
-    }
-}
-
-export default CRC8Checksum;

src/core/operations/CSSSelector.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
-import xmldom from "xmldom";
+import xmldom from "@xmldom/xmldom";
 import nwmatcher from "nwmatcher";
 
 /**

src/core/operations/CTPH.mjs

@@ -21,7 +21,7 @@ class CTPH extends Operation {
         this.name = "CTPH";
         this.module = "Crypto";
         this.description = "Context Triggered Piecewise Hashing, also called Fuzzy Hashing, can match inputs that have homologies. Such inputs have sequences of identical bytes in the same order, although bytes in between these sequences may be different in both content and length.<br><br>CTPH was originally based on the work of Dr. Andrew Tridgell and a spam email detector called SpamSum. This method was adapted by Jesse Kornblum and published at the DFRWS conference in 2006 in a paper 'Identifying Almost Identical Files Using Context Triggered Piecewise Hashing'.";
-        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing";
+        this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/";
         this.inputType = "string";
         this.outputType = "string";
         this.args = [];

src/core/operations/CaretMdecode.mjs

@@ -0,0 +1,98 @@
+/**
+ * @author tedk [tedk@ted.do]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Caret/M-decode operation
+ *
+ * https://gist.githubusercontent.com/JaHIY/3c91bbf7bea5661e6abfbd1349ee81a2/raw/c7b480e9ff24bcb8f5287a8a8a2dcb9bf5628506/decode_m_notation.cpp
+ */
+class CaretMdecode extends Operation {
+
+    /**
+     * CaretMdecode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Caret/M-decode";
+        this.module = "Default";
+        this.description = "Decodes caret or M-encoded strings, i.e. ^M turns into a newline, M-^] turns into 0x9d. Sources such as `cat -v`.\n\nPlease be aware that when using `cat -v` ^_ (caret-underscore) will not be encoded, but represents a valid encoding (namely that of 0x1f).";
+        this.infoURL = "https://en.wikipedia.org/wiki/Caret_notation";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+
+        const bytes = [];
+
+        let prev = "";
+
+        for (let i = 0; i < input.length; i++) {
+
+            const charCode = input.charCodeAt(i);
+            const curChar = input.charAt(i);
+
+            if (prev === "M-^") {
+                if (charCode > 63 && charCode <= 95) {
+                    bytes.push(charCode + 64);
+                } else if (charCode === 63) {
+                    bytes.push(255);
+                } else {
+                    bytes.push(77, 45, 94, charCode);
+                }
+                prev = "";
+            } else if (prev === "M-") {
+                if (curChar === "^") {
+                    prev = prev + "^";
+                } else if (charCode >= 32 && charCode <= 126) {
+                    bytes.push(charCode + 128);
+                    prev = "";
+                } else {
+                    bytes.push(77, 45, charCode);
+                    prev = "";
+                }
+            } else if (prev === "M") {
+                if (curChar === "-") {
+                    prev = prev + "-";
+                } else {
+                    bytes.push(77, charCode);
+                    prev = "";
+                }
+            } else if (prev === "^") {
+                if (charCode > 63 && charCode <= 126) {
+                    bytes.push(charCode - 64);
+                } else if (charCode === 63) {
+                    bytes.push(127);
+                } else {
+                    bytes.push(94, charCode);
+                }
+                prev = "";
+            } else {
+                if (curChar === "M") {
+                    prev = "M";
+                } else if (curChar === "^") {
+                    prev = "^";
+                } else {
+                    bytes.push(charCode);
+                }
+            }
+
+        }
+        return bytes;
+    }
+
+}
+
+export default CaretMdecode;

src/core/operations/ChaCha.mjs

@@ -100,7 +100,7 @@ class ChaCha extends Operation {
         super();
 
         this.name = "ChaCha";
-        this.module = "Default";
+        this.module = "Ciphers";
         this.description = "ChaCha is a stream cipher designed by Daniel J. Bernstein. It is a variant of the Salsa stream cipher. Several parameterizations exist; 'ChaCha' may refer to the original construction, or to the variant as described in RFC-8439. ChaCha is often used with Poly1305, in the ChaCha20-Poly1305 AEAD construction.<br><br><b>Key:</b> ChaCha uses a key of 16 or 32 bytes (128 or 256 bits).<br><br><b>Nonce:</b> ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).<br><br><b>Counter:</b> ChaCha uses a counter of 4 or 8 bytes (32 or 64 bits); together, the nonce and counter must add up to 16 bytes. The counter starts at zero at the start of the keystream, and is incremented at every 64 bytes.";
         this.infoURL = "https://wikipedia.org/wiki/Salsa20#ChaCha_variant";
         this.inputType = "string";
@@ -191,7 +191,7 @@ ChaCha uses a nonce of 8 or 12 bytes (64 or 96 bits).`);
         if (outputType === "Hex") {
             return toHex(output);
         } else {
-            return Utils.arrayBufferToStr(output);
+            return Utils.arrayBufferToStr(Uint8Array.from(output).buffer);
         }
     }
 

src/core/operations/CompareCTPHHashes.mjs

@@ -24,7 +24,7 @@ class CompareCTPHHashes extends Operation {
         this.name = "Compare CTPH hashes";
         this.module = "Crypto";
         this.description = "Compares two Context Triggered Piecewise Hashing (CTPH) fuzzy hashes to determine the similarity between them on a scale of 0 to 100.";
-        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Context_Triggered_Piecewise_Hashing";
+        this.infoURL = "https://forensics.wiki/context_triggered_piecewise_hashing/";
         this.inputType = "string";
         this.outputType = "Number";
         this.args = [

src/core/operations/CompareSSDEEPHashes.mjs

@@ -24,7 +24,7 @@ class CompareSSDEEPHashes extends Operation {
         this.name = "Compare SSDEEP hashes";
         this.module = "Crypto";
         this.description = "Compares two SSDEEP fuzzy hashes to determine the similarity between them on a scale of 0 to 100.";
-        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=Ssdeep";
+        this.infoURL = "https://forensics.wiki/ssdeep/";
         this.inputType = "string";
         this.outputType = "Number";
         this.args = [

src/core/operations/ContainImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Contain Image operation
@@ -92,20 +91,20 @@ class ContainImage extends Operation {
         const [width, height, hAlign, vAlign, alg, opaqueBg] = 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": Jimp.RESIZE_NEAREST_NEIGHBOR,
+            "Bilinear": Jimp.RESIZE_BILINEAR,
+            "Bicubic": Jimp.RESIZE_BICUBIC,
+            "Hermite": Jimp.RESIZE_HERMITE,
+            "Bezier": Jimp.RESIZE_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": 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
         };
 
         if (!isImage(input)) {
@@ -114,7 +113,7 @@ class ContainImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -124,16 +123,16 @@ class ContainImage extends Operation {
             image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
 
             if (opaqueBg) {
-                const newImage = await jimp.read(width, height, 0x000000FF);
+                const newImage = await Jimp.read(width, height, 0x000000FF);
                 newImage.blit(image, 0, 0);
                 image = newImage;
             }
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/ConvertImageFormat.mjs

@@ -8,8 +8,7 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Convert Image Format operation
@@ -77,19 +76,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": Jimp.MIME_JPEG,
+            "PNG": Jimp.MIME_PNG,
+            "BMP": Jimp.MIME_BMP,
+            "TIFF": Jimp.MIME_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": 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
         };
 
         const mime = formatMap[format];
@@ -99,7 +98,7 @@ class ConvertImageFormat extends Operation {
         }
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error opening image file. (${err})`);
         }

src/core/operations/ConvertLeetSpeak.mjs

@@ -0,0 +1,116 @@
+/**
+ * @author bartblaze []
+ * @copyright Crown Copyright 2025
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * Convert Leet Speak operation
+ */
+class ConvertLeetSpeak extends Operation {
+    /**
+     * ConvertLeetSpeak constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Convert Leet Speak";
+        this.module = "Default";
+        this.description = "Converts to and from Leet Speak.";
+        this.infoURL = "https://wikipedia.org/wiki/Leet";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Direction",
+                type: "option",
+                value: ["To Leet Speak", "From Leet Speak"],
+                defaultIndex: 0
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const direction = args[0];
+
+        if (direction === "To Leet Speak") {
+            return input.replace(/[a-z]/gi, char => {
+                const leetChar = toLeetMap[char.toLowerCase()] || char;
+                return char === char.toUpperCase() ? leetChar.toUpperCase() : leetChar;
+            });
+        } else if (direction === "From Leet Speak") {
+            return input.replace(/[48cd3f6h1jklmn0pqr57uvwxyz]/gi, char => {
+                const normalChar = fromLeetMap[char] || char;
+                return normalChar;
+            });
+        }
+    }
+}
+
+const toLeetMap = {
+    "a": "4",
+    "b": "b",
+    "c": "c",
+    "d": "d",
+    "e": "3",
+    "f": "f",
+    "g": "g",
+    "h": "h",
+    "i": "1",
+    "j": "j",
+    "k": "k",
+    "l": "l",
+    "m": "m",
+    "n": "n",
+    "o": "0",
+    "p": "p",
+    "q": "q",
+    "r": "r",
+    "s": "5",
+    "t": "7",
+    "u": "u",
+    "v": "v",
+    "w": "w",
+    "x": "x",
+    "y": "y",
+    "z": "z"
+};
+
+const fromLeetMap = {
+    "4": "a",
+    "b": "b",
+    "c": "c",
+    "d": "d",
+    "3": "e",
+    "f": "f",
+    "g": "g",
+    "h": "h",
+    "1": "i",
+    "j": "j",
+    "k": "k",
+    "l": "l",
+    "m": "m",
+    "n": "n",
+    "0": "o",
+    "p": "p",
+    "q": "q",
+    "r": "r",
+    "5": "s",
+    "7": "t",
+    "u": "u",
+    "v": "v",
+    "w": "w",
+    "x": "x",
+    "y": "y",
+    "z": "z"
+};
+
+export default ConvertLeetSpeak;
+

src/core/operations/CoverImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import jimp from "jimp/es/index.js";
 
 /**
  * Cover Image operation

src/core/operations/CropImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Crop Image operation
@@ -100,7 +99,7 @@ class CropImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -120,9 +119,9 @@ class CropImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/DESDecrypt.mjs

@@ -22,7 +22,7 @@ class DESDecrypt extends Operation {
 
         this.name = "DES Decrypt";
         this.module = "Ciphers";
-        this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used as a default.";
+        this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used as a default.";
         this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard";
         this.inputType = "string";
         this.outputType = "string";
@@ -72,8 +72,7 @@ class DESDecrypt extends Operation {
         if (key.length !== 8) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
 
-DES uses a key length of 8 bytes (64 bits).
-Triple DES uses a key length of 24 bytes (192 bits).`);
+DES uses a key length of 8 bytes (64 bits).`);
         }
         if (iv.length !== 8 && mode !== "ECB") {
             throw new OperationError(`Invalid IV length: ${iv.length} bytes

src/core/operations/DESEncrypt.mjs

@@ -22,7 +22,7 @@ class DESEncrypt extends Operation {
 
         this.name = "DES Encrypt";
         this.module = "Ciphers";
-        this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br>Triple DES uses a key length of 24 bytes (192 bits).<br><br>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used.";
+        this.description = "DES is a previously dominant algorithm for encryption, and was published as an official U.S. Federal Information Processing Standard (FIPS). It is now considered to be insecure due to its small key size.<br><br><b>Key:</b> DES uses a key length of 8 bytes (64 bits).<br><br>You can generate a password-based key using one of the KDF operations.<br><br><b>IV:</b> The Initialization Vector should be 8 bytes long. If not entered, it will default to 8 null bytes.<br><br><b>Padding:</b> In CBC and ECB mode, PKCS#7 padding will be used.";
         this.infoURL = "https://wikipedia.org/wiki/Data_Encryption_Standard";
         this.inputType = "string";
         this.outputType = "string";
@@ -70,8 +70,7 @@ class DESEncrypt extends Operation {
         if (key.length !== 8) {
             throw new OperationError(`Invalid key length: ${key.length} bytes
 
-DES uses a key length of 8 bytes (64 bits).
-Triple DES uses a key length of 24 bytes (192 bits).`);
+DES uses a key length of 8 bytes (64 bits).`);
         }
         if (iv.length !== 8 && mode !== "ECB") {
             throw new OperationError(`Invalid IV length: ${iv.length} bytes

src/core/operations/DateTimeDelta.mjs

@@ -0,0 +1,107 @@
+/**
+ * @author tomgond [tom.gonda@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import moment from "moment-timezone";
+import {DATETIME_FORMATS, FORMAT_EXAMPLES} from "../lib/DateTime.mjs";
+
+/**
+ * DateTime Delta operation
+ */
+class DateTimeDelta extends Operation {
+
+    /**
+     * DateTimeDelta constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "DateTime Delta";
+        this.module = "Default";
+        this.description = "Calculates a new DateTime value given an input DateTime value and a time difference (delta) from the input DateTime value.";
+        this.inputType = "string";
+        this.outputType = "html";
+        this.args = [
+            {
+                "name": "Built in formats",
+                "type": "populateOption",
+                "value": DATETIME_FORMATS,
+                "target": 1
+            },
+            {
+                "name": "Input format string",
+                "type": "binaryString",
+                "value": "DD/MM/YYYY HH:mm:ss"
+            },
+            {
+                "name": "Time Operation",
+                "type": "option",
+                "value": ["Add", "Subtract"]
+            },
+            {
+                "name": "Days",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Hours",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Minutes",
+                "type": "number",
+                "value": 0
+            },
+            {
+                "name": "Seconds",
+                "type": "number",
+                "value": 0
+            }
+
+        ];
+    }
+
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const inputTimezone = "UTC";
+        const inputFormat = args[1];
+        const operationType = args[2];
+        const daysDelta = args[3];
+        const hoursDelta = args[4];
+        const minutesDelta = args[5];
+        const secondsDelta = args[6];
+        let date = "";
+
+        try {
+            date = moment.tz(input, inputFormat, inputTimezone);
+            if (!date || date.format() === "Invalid date") throw Error;
+        } catch (err) {
+            return `Invalid format.\n\n${FORMAT_EXAMPLES}`;
+        }
+        let newDate;
+        if (operationType === "Add") {
+            newDate = date.add(daysDelta, "days")
+                .add(hoursDelta, "hours")
+                .add(minutesDelta, "minutes")
+                .add(secondsDelta, "seconds");
+
+        } else {
+            newDate = date.add(-daysDelta, "days")
+                .add(-hoursDelta, "hours")
+                .add(-minutesDelta, "minutes")
+                .add(-secondsDelta, "seconds");
+        }
+        return newDate.tz(inputTimezone).format(inputFormat.replace(/[<>]/g, ""));
+    }
+}
+
+export default DateTimeDelta;

src/core/operations/DecodeText.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import cptable from "codepage";
-import {IO_FORMAT} from "../lib/ChrEnc.mjs";
+import {CHR_ENC_CODE_PAGES} from "../lib/ChrEnc.mjs";
 
 /**
  * Decode text operation
@@ -26,7 +26,7 @@ class DecodeText extends Operation {
             "<br><br>",
             "Supported charsets are:",
             "<ul>",
-            Object.keys(IO_FORMAT).map(e => `<li>${e}</li>`).join("\n"),
+            Object.keys(CHR_ENC_CODE_PAGES).map(e => `<li>${e}</li>`).join("\n"),
             "</ul>",
         ].join("\n");
         this.infoURL = "https://wikipedia.org/wiki/Character_encoding";
@@ -36,7 +36,7 @@ class DecodeText extends Operation {
             {
                 "name": "Encoding",
                 "type": "option",
-                "value": Object.keys(IO_FORMAT)
+                "value": Object.keys(CHR_ENC_CODE_PAGES)
             }
         ];
     }
@@ -47,7 +47,7 @@ class DecodeText extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const format = IO_FORMAT[args[0]];
+        const format = CHR_ENC_CODE_PAGES[args[0]];
         return cptable.utils.decode(format, new Uint8Array(input));
     }
 

src/core/operations/DeriveEVPKey.mjs

@@ -62,11 +62,13 @@ class DeriveEVPKey extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const passphrase = Utils.convertToByteString(args[0].string, args[0].option),
+        const passphrase = CryptoJS.enc.Latin1.parse(
+                Utils.convertToByteString(args[0].string, args[0].option)),
             keySize = args[1] / 32,
             iterations = args[2],
             hasher = args[3],
-            salt = Utils.convertToByteString(args[4].string, args[4].option),
+            salt = CryptoJS.enc.Latin1.parse(
+                Utils.convertToByteString(args[4].string, args[4].option)),
             key = CryptoJS.EvpKDF(passphrase, salt, { // lgtm [js/insufficient-password-hash]
                 keySize: keySize,
                 hasher: CryptoJS.algo[hasher],

src/core/operations/DeriveHKDFKey.mjs

@@ -0,0 +1,138 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import CryptoApi from "crypto-api/src/crypto-api.mjs";
+
+/**
+ * Derive HKDF Key operation
+ */
+class DeriveHKDFKey extends Operation {
+
+    /**
+     * DeriveHKDFKey constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Derive HKDF key";
+        this.module = "Crypto";
+        this.description = "A simple Hashed Message Authenticaton Code (HMAC)-based key derivation function (HKDF), defined in RFC5869.";
+        this.infoURL = "https://wikipedia.org/wiki/HKDF";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Salt",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+            },
+            {
+                "name": "Info",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "Decimal", "Base64", "UTF8", "Latin1"]
+            },
+            {
+                "name": "Hashing function",
+                "type": "option",
+                "value": [
+                    "MD2",
+                    "MD4",
+                    "MD5",
+                    "SHA0",
+                    "SHA1",
+                    "SHA224",
+                    "SHA256",
+                    "SHA384",
+                    "SHA512",
+                    "SHA512/224",
+                    "SHA512/256",
+                    "RIPEMD128",
+                    "RIPEMD160",
+                    "RIPEMD256",
+                    "RIPEMD320",
+                    "HAS160",
+                    "Whirlpool",
+                    "Whirlpool-0",
+                    "Whirlpool-T",
+                    "Snefru"
+                ],
+                "defaultIndex": 6
+            },
+            {
+                "name": "Extract mode",
+                "type": "argSelector",
+                "value": [
+                    {
+                        "name": "with salt",
+                        "on": [0]
+                    },
+                    {
+                        "name": "no salt",
+                        "off": [0]
+                    },
+                    {
+                        "name": "skip",
+                        "off": [0]
+                    }
+                ]
+            },
+            {
+                "name": "L (number of output octets)",
+                "type": "number",
+                "value": 16,
+                "min": 0
+            },
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        const argSalt = Utils.convertToByteString(args[0].string || "", args[0].option),
+            info = Utils.convertToByteString(args[1].string || "", args[1].option),
+            hashFunc = args[2].toLowerCase(),
+            extractMode = args[3],
+            L = args[4],
+            IKM = Utils.arrayBufferToStr(input, false),
+            hasher = CryptoApi.getHasher(hashFunc),
+            HashLen = hasher.finalize().length;
+
+        if (L < 0) {
+            throw new OperationError("L must be non-negative");
+        }
+        if (L > 255 * HashLen) {
+            throw new OperationError("L too large (maximum length for " + args[2] + " is " + (255 * HashLen) + ")");
+        }
+
+        const hmacHash = function(key, data) {
+            hasher.reset();
+            const mac = CryptoApi.getHmac(key, hasher);
+            mac.update(data);
+            return mac.finalize();
+        };
+        const salt = extractMode === "with salt" ? argSalt : "\0".repeat(HashLen);
+        const PRK = extractMode === "skip" ? IKM : hmacHash(salt, IKM);
+        let T = "";
+        let result = "";
+        for (let i = 1; i <= 255 && result.length < L; i++) {
+            const TNext = hmacHash(PRK, T + info + String.fromCharCode(i));
+            result += TNext;
+            T = TNext;
+        }
+        return CryptoApi.encoder.toHex(result.substring(0, L));
+    }
+
+}
+
+export default DeriveHKDFKey;

src/core/operations/DetectFileType.mjs

@@ -65,7 +65,7 @@ class DetectFileType extends Operation {
 Extension:   ${type.extension}
 MIME type:   ${type.mime}\n`;
 
-                if (type.description && type.description.length) {
+                if (type?.description?.length) {
                     output += `Description: ${type.description}\n`;
                 }
 

src/core/operations/Diff.mjs

@@ -119,9 +119,9 @@ class Diff extends Operation {
 
         for (let i = 0; i < diff.length; i++) {
             if (diff[i].added) {
-                if (showAdded) output += "<span class='hl5'>" + Utils.escapeHtml(diff[i].value) + "</span>";
+                if (showAdded) output += "<ins>" + Utils.escapeHtml(diff[i].value) + "</ins>";
             } else if (diff[i].removed) {
-                if (showRemoved) output += "<span class='hl3'>" + Utils.escapeHtml(diff[i].value) + "</span>";
+                if (showRemoved) output += "<del>" + Utils.escapeHtml(diff[i].value) + "</del>";
             } else if (!showSubtraction) {
                 output += Utils.escapeHtml(diff[i].value);
             }

src/core/operations/DitherImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Image Dither operation
@@ -45,7 +44,7 @@ class DitherImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -56,9 +55,9 @@ class DitherImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/DropNthBytes.mjs

@@ -0,0 +1,79 @@
+/**
+ * @author Oshawk [oshawk@protonmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Drop nth bytes operation
+ */
+class DropNthBytes extends Operation {
+
+    /**
+     * DropNthBytes constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Drop nth bytes";
+        this.module = "Default";
+        this.description = "Drops every nth byte starting with a given byte.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                name: "Drop every",
+                type: "number",
+                value: 4
+            },
+            {
+                name: "Starting at",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Apply to each line",
+                type: "boolean",
+                value: false
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        const n = args[0];
+        const start = args[1];
+        const eachLine = args[2];
+
+        if (parseInt(n, 10) !== n || n <= 0) {
+            throw new OperationError("'Drop every' must be a positive integer.");
+        }
+        if (parseInt(start, 10) !== start || start < 0) {
+            throw new OperationError("'Starting at' must be a positive or zero integer.");
+        }
+
+        let offset = 0;
+        const output = [];
+        for (let i = 0; i < input.length; i++) {
+            if (eachLine && input[i] === 0x0a) {
+                output.push(0x0a);
+                offset = i + 1;
+            } else if (i - offset < start || (i - (start + offset)) % n !== 0) {
+                output.push(input[i]);
+            }
+        }
+
+        return output;
+    }
+
+}
+
+export default DropNthBytes;

src/core/operations/ECDSASign.mjs

@@ -0,0 +1,107 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromHex } from "../lib/Hex.mjs";
+import { toBase64 } from "../lib/Base64.mjs";
+import r from "jsrsasign";
+
+/**
+ * ECDSA Sign operation
+ */
+class ECDSASign extends Operation {
+
+    /**
+     * ECDSASign constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "ECDSA Sign";
+        this.module = "Ciphers";
+        this.description = "Sign a plaintext message with a PEM encoded EC key.";
+        this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "ECDSA Private Key (PEM)",
+                type: "text",
+                value: "-----BEGIN EC PRIVATE KEY-----"
+            },
+            {
+                name: "Message Digest Algorithm",
+                type: "option",
+                value: [
+                    "SHA-256",
+                    "SHA-384",
+                    "SHA-512",
+                    "SHA-1",
+                    "MD5"
+                ]
+            },
+            {
+                name: "Output Format",
+                type: "option",
+                value: [
+                    "ASN.1 HEX",
+                    "P1363 HEX",
+                    "JSON Web Signature",
+                    "Raw JSON"
+                ]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [keyPem, mdAlgo, outputFormat] = args;
+
+        if (keyPem.replace("-----BEGIN EC PRIVATE KEY-----", "").length === 0) {
+            throw new OperationError("Please enter a private key.");
+        }
+
+        const internalAlgorithmName = mdAlgo.replace("-", "") + "withECDSA";
+        const sig = new r.KJUR.crypto.Signature({ alg: internalAlgorithmName });
+        const key = r.KEYUTIL.getKey(keyPem);
+        if (key.type !== "EC") {
+            throw new OperationError("Provided key is not an EC key.");
+        }
+        if (!key.isPrivate) {
+            throw new OperationError("Provided key is not a private key.");
+        }
+        sig.init(key);
+        const signatureASN1Hex = sig.signString(input);
+
+        let result;
+        switch (outputFormat) {
+            case "ASN.1 HEX":
+                result = signatureASN1Hex;
+                break;
+            case "P1363 HEX":
+                result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+                break;
+            case "JSON Web Signature":
+                result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+                result = toBase64(fromHex(result), "A-Za-z0-9-_");  // base64url
+                break;
+            case "Raw JSON": {
+                const signatureRS = r.KJUR.crypto.ECDSA.parseSigHexInHexRS(signatureASN1Hex);
+                result = JSON.stringify(signatureRS);
+                break;
+            }
+        }
+
+        return result;
+    }
+}
+
+export default ECDSASign;

src/core/operations/ECDSASignatureConversion.mjs

@@ -0,0 +1,146 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromBase64, toBase64 } from "../lib/Base64.mjs";
+import { fromHex, toHexFast } from "../lib/Hex.mjs";
+import r from "jsrsasign";
+
+/**
+ * ECDSA Sign operation
+ */
+class ECDSASignatureConversion extends Operation {
+
+    /**
+     * ECDSASignatureConversion constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "ECDSA Signature Conversion";
+        this.module = "Ciphers";
+        this.description = "Convert an ECDSA signature between hex, asn1 and json.";
+        this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input Format",
+                type: "option",
+                value: [
+                    "Auto",
+                    "ASN.1 HEX",
+                    "P1363 HEX",
+                    "JSON Web Signature",
+                    "Raw JSON"
+                ]
+            },
+            {
+                name: "Output Format",
+                type: "option",
+                value: [
+                    "ASN.1 HEX",
+                    "P1363 HEX",
+                    "JSON Web Signature",
+                    "Raw JSON"
+                ]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        let inputFormat = args[0];
+        const outputFormat = args[1];
+
+        // detect input format
+        let inputJson;
+        if (inputFormat === "Auto") {
+            try {
+                inputJson = JSON.parse(input);
+                if (typeof(inputJson) === "object") {
+                    inputFormat = "Raw JSON";
+                }
+            } catch {}
+        }
+
+        if (inputFormat === "Auto") {
+            const hexRegex = /^[a-f\d]{2,}$/gi;
+            if (hexRegex.test(input)) {
+                if (input.substring(0, 2) === "30" && r.ASN1HEX.isASN1HEX(input)) {
+                    inputFormat = "ASN.1 HEX";
+                } else {
+                    inputFormat = "P1363 HEX";
+                }
+            }
+        }
+
+        let inputBase64;
+        if (inputFormat === "Auto") {
+            try {
+                inputBase64 = fromBase64(input, "A-Za-z0-9-_", false);
+                inputFormat = "JSON Web Signature";
+            } catch {}
+        }
+
+        // convert input to ASN.1 hex
+        let signatureASN1Hex;
+        switch (inputFormat) {
+            case "Auto":
+                throw new OperationError("Signature format could not be detected");
+            case "ASN.1 HEX":
+                signatureASN1Hex = input;
+                break;
+            case "P1363 HEX":
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(input);
+                break;
+            case "JSON Web Signature":
+                if (!inputBase64) inputBase64 = fromBase64(input, "A-Za-z0-9-_");
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(toHexFast(inputBase64));
+                break;
+            case "Raw JSON": {
+                if (!inputJson) inputJson = JSON.parse(input);
+                if (!inputJson.r) {
+                    throw new OperationError('No "r" value in the signature JSON');
+                }
+                if (!inputJson.s) {
+                    throw new OperationError('No "s" value in the signature JSON');
+                }
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.hexRSSigToASN1Sig(inputJson.r, inputJson.s);
+                break;
+            }
+        }
+
+        // convert ASN.1 hex to output format
+        let result;
+        switch (outputFormat) {
+            case "ASN.1 HEX":
+                result = signatureASN1Hex;
+                break;
+            case "P1363 HEX":
+                result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+                break;
+            case "JSON Web Signature":
+                result = r.KJUR.crypto.ECDSA.asn1SigToConcatSig(signatureASN1Hex);
+                result = toBase64(fromHex(result), "A-Za-z0-9-_");  // base64url
+                break;
+            case "Raw JSON": {
+                const signatureRS = r.KJUR.crypto.ECDSA.parseSigHexInHexRS(signatureASN1Hex);
+                result = JSON.stringify(signatureRS);
+                break;
+            }
+        }
+
+        return result;
+    }
+}
+
+export default ECDSASignatureConversion;

src/core/operations/ECDSAVerify.mjs

@@ -0,0 +1,154 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import { fromBase64 } from "../lib/Base64.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import r from "jsrsasign";
+
+/**
+ * ECDSA Verify operation
+ */
+class ECDSAVerify extends Operation {
+
+    /**
+     * ECDSAVerify constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "ECDSA Verify";
+        this.module = "Ciphers";
+        this.description = "Verify a message against a signature and a public PEM encoded EC key.";
+        this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input Format",
+                type: "option",
+                value: [
+                    "Auto",
+                    "ASN.1 HEX",
+                    "P1363 HEX",
+                    "JSON Web Signature",
+                    "Raw JSON"
+                ]
+            },
+            {
+                name: "Message Digest Algorithm",
+                type: "option",
+                value: [
+                    "SHA-256",
+                    "SHA-384",
+                    "SHA-512",
+                    "SHA-1",
+                    "MD5"
+                ]
+            },
+            {
+                name: "ECDSA Public Key (PEM)",
+                type: "text",
+                value: "-----BEGIN PUBLIC KEY-----"
+            },
+            {
+                name: "Message",
+                type: "text",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        let inputFormat = args[0];
+        const [, mdAlgo, keyPem, msg] = args;
+
+        if (keyPem.replace("-----BEGIN PUBLIC KEY-----", "").length === 0) {
+            throw new OperationError("Please enter a public key.");
+        }
+
+        // detect input format
+        let inputJson;
+        if (inputFormat === "Auto") {
+            try {
+                inputJson = JSON.parse(input);
+                if (typeof(inputJson) === "object") {
+                    inputFormat = "Raw JSON";
+                }
+            } catch {}
+        }
+
+        if (inputFormat === "Auto") {
+            const hexRegex = /^[a-f\d]{2,}$/gi;
+            if (hexRegex.test(input)) {
+                if (input.substring(0, 2) === "30" && r.ASN1HEX.isASN1HEX(input)) {
+                    inputFormat = "ASN.1 HEX";
+                } else {
+                    inputFormat = "P1363 HEX";
+                }
+            }
+        }
+
+        let inputBase64;
+        if (inputFormat === "Auto") {
+            try {
+                inputBase64 = fromBase64(input, "A-Za-z0-9-_", false);
+                inputFormat = "JSON Web Signature";
+            } catch {}
+        }
+
+        // convert to ASN.1 signature
+        let signatureASN1Hex;
+        switch (inputFormat) {
+            case "Auto":
+                throw new OperationError("Signature format could not be detected");
+            case "ASN.1 HEX":
+                signatureASN1Hex = input;
+                break;
+            case "P1363 HEX":
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(input);
+                break;
+            case "JSON Web Signature":
+                if (!inputBase64) inputBase64 = fromBase64(input, "A-Za-z0-9-_");
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.concatSigToASN1Sig(toHexFast(inputBase64));
+                break;
+            case "Raw JSON": {
+                if (!inputJson) inputJson = JSON.parse(input);
+                if (!inputJson.r) {
+                    throw new OperationError('No "r" value in the signature JSON');
+                }
+                if (!inputJson.s) {
+                    throw new OperationError('No "s" value in the signature JSON');
+                }
+                signatureASN1Hex = r.KJUR.crypto.ECDSA.hexRSSigToASN1Sig(inputJson.r, inputJson.s);
+                break;
+            }
+        }
+
+        // verify signature
+        const internalAlgorithmName = mdAlgo.replace("-", "") + "withECDSA";
+        const sig = new r.KJUR.crypto.Signature({ alg: internalAlgorithmName });
+        const key = r.KEYUTIL.getKey(keyPem);
+        if (key.type !== "EC") {
+            throw new OperationError("Provided key is not an EC key.");
+        }
+        if (!key.isPublic) {
+            throw new OperationError("Provided key is not a public key.");
+        }
+        sig.init(key);
+        sig.updateString(msg);
+        const result = sig.verify(signatureASN1Hex);
+        return result ? "Verified OK" : "Verification Failure";
+    }
+}
+
+export default ECDSAVerify;

src/core/operations/EncodeText.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import cptable from "codepage";
-import {IO_FORMAT} from "../lib/ChrEnc.mjs";
+import {CHR_ENC_CODE_PAGES} from "../lib/ChrEnc.mjs";
 
 /**
  * Encode text operation
@@ -26,7 +26,7 @@ class EncodeText extends Operation {
             "<br><br>",
             "Supported charsets are:",
             "<ul>",
-            Object.keys(IO_FORMAT).map(e => `<li>${e}</li>`).join("\n"),
+            Object.keys(CHR_ENC_CODE_PAGES).map(e => `<li>${e}</li>`).join("\n"),
             "</ul>",
         ].join("\n");
         this.infoURL = "https://wikipedia.org/wiki/Character_encoding";
@@ -36,7 +36,7 @@ class EncodeText extends Operation {
             {
                 "name": "Encoding",
                 "type": "option",
-                "value": Object.keys(IO_FORMAT)
+                "value": Object.keys(CHR_ENC_CODE_PAGES)
             }
         ];
     }
@@ -47,7 +47,7 @@ class EncodeText extends Operation {
      * @returns {ArrayBuffer}
      */
     run(input, args) {
-        const format = IO_FORMAT[args[0]];
+        const format = CHR_ENC_CODE_PAGES[args[0]];
         const encoded = cptable.utils.encode(format, input);
         return new Uint8Array(encoded).buffer;
     }

src/core/operations/Entropy.mjs

@@ -358,7 +358,7 @@ class Entropy extends Operation {
 
         <br><script>
             var canvas = document.getElementById("chart-area"),
-                parentRect = canvas.parentNode.getBoundingClientRect(),
+                parentRect = canvas.closest(".cm-scroller").getBoundingClientRect(),
                 entropy = ${entropy},
                 height = parentRect.height * 0.25;
 

src/core/operations/ExtractDomains.mjs

@@ -5,7 +5,7 @@
  */
 
 import Operation from "../Operation.mjs";
-import { search, DOMAIN_REGEX } from "../lib/Extract.mjs";
+import { search, DOMAIN_REGEX, DMARC_DOMAIN_REGEX } from "../lib/Extract.mjs";
 import { caseInsensitiveSort } from "../lib/Sort.mjs";
 
 /**
@@ -39,6 +39,11 @@ class ExtractDomains extends Operation {
                 name: "Unique",
                 type: "boolean",
                 value: false
+            },
+            {
+                name: "Underscore (DMARC, DKIM, etc)",
+                type: "boolean",
+                value: false
             }
         ];
     }
@@ -49,11 +54,11 @@ class ExtractDomains extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const [displayTotal, sort, unique] = args;
+        const [displayTotal, sort, unique, dmarc] = args;
 
         const results = search(
             input,
-            DOMAIN_REGEX,
+            dmarc ? DMARC_DOMAIN_REGEX : DOMAIN_REGEX,
             null,
             sort ? caseInsensitiveSort : null,
             unique

src/core/operations/ExtractFiles.mjs

@@ -39,7 +39,7 @@ class ExtractFiles extends Operation {
                 ${supportedExts.join("</li><li>")}
                 </li>
             </ul>Minimum File Size can be used to prune small false positives.`;
-        this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=File_Carving";
+        this.infoURL = "https://forensics.wiki/file_carving";
         this.inputType = "ArrayBuffer";
         this.outputType = "List<File>";
         this.presentType = "html";

src/core/operations/ExtractHashes.mjs

@@ -0,0 +1,84 @@
+/**
+ * @author mshwed [m@ttshwed.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import { search } from "../lib/Extract.mjs";
+
+/**
+ * Extract Hash Values operation
+ */
+class ExtractHashes extends Operation {
+
+    /**
+     * ExtractHashValues constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Extract hashes";
+        this.module = "Regex";
+        this.description = "Extracts potential hashes based on hash character length";
+        this.infoURL = "https://wikipedia.org/wiki/Comparison_of_cryptographic_hash_functions";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Hash character length",
+                type: "number",
+                value: 40
+            },
+            {
+                name: "All hashes",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Display Total",
+                type: "boolean",
+                value: false
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const results = [];
+        let hashCount = 0;
+
+        const [hashLength, searchAllHashes, showDisplayTotal] = args;
+
+        // Convert character length to bit length
+        let hashBitLengths = [(hashLength / 2) * 8];
+
+        if (searchAllHashes) hashBitLengths = [4, 8, 16, 32, 64, 128, 160, 192, 224, 256, 320, 384, 512, 1024];
+
+        for (const hashBitLength of hashBitLengths) {
+            // Convert bit length to character length
+            const hashCharacterLength = (hashBitLength / 8) * 2;
+
+            const regex = new RegExp(`(\\b|^)[a-f0-9]{${hashCharacterLength}}(\\b|$)`, "g");
+            const searchResults = search(input, regex, null, false);
+
+            hashCount += searchResults.length;
+            results.push(...searchResults);
+        }
+
+        let output = "";
+        if (showDisplayTotal) {
+            output = `Total Results: ${hashCount}\n\n`;
+        }
+
+        output = output + results.join("\n");
+        return output;
+    }
+
+}
+
+export default ExtractHashes;

src/core/operations/ExtractIPAddresses.mjs

@@ -66,7 +66,7 @@ class ExtractIPAddresses extends Operation {
     run(input, args) {
         const [includeIpv4, includeIpv6, removeLocal, displayTotal, sort, unique] = args,
             ipv4 = "(?:(?:\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d|\\d)(?:\\/\\d{1,2})?",
-            ipv6 = "((?=.*::)(?!.*::.+::)(::)?([\\dA-F]{1,4}:(:|\\b)|){5}|([\\dA-F]{1,4}:){6})((([\\dA-F]{1,4}((?!\\3)::|:\\b|(?![\\dA-F])))|(?!\\2\\3)){2}|(((2[0-4]|1\\d|[1-9])?\\d|25[0-5])\\.?\\b){4})";
+            ipv6 = "((?=.*::)(?!.*::.+::)(::)?([\\dA-F]{1,4}:(:|\\b)|){5}|([\\dA-F]{1,4}:){6})(([\\dA-F]{1,4}((?!\\3)::|:\\b|(?![\\dA-F])))|(?!\\2\\3)){2}";
         let ips  = "";
 
         if (includeIpv4 && includeIpv6) {

src/core/operations/ExtractLSB.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import Utils from "../Utils.mjs";
 import { fromBinary } from "../lib/Binary.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Extract LSB operation
@@ -74,7 +73,7 @@ class ExtractLSB extends Operation {
         const bit = 7 - args.pop(),
             pixelOrder = args.pop(),
             colours = args.filter(option => option !== "").map(option => COLOUR_OPTIONS.indexOf(option)),
-            parsedImage = await jimp.read(input),
+            parsedImage = await Jimp.read(input),
             width = parsedImage.bitmap.width,
             height = parsedImage.bitmap.height,
             rgba = parsedImage.bitmap.data;

src/core/operations/ExtractRGBA.mjs

@@ -7,8 +7,7 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 import {RGBA_DELIM_OPTIONS} from "../lib/Delim.mjs";
 
@@ -53,7 +52,7 @@ class ExtractRGBA extends Operation {
 
         const delimiter = args[0],
             includeAlpha = args[1],
-            parsedImage = await jimp.read(input);
+            parsedImage = await Jimp.read(input);
 
         let bitmap = parsedImage.bitmap.data;
         bitmap = includeAlpha ? bitmap : bitmap.filter((val, idx) => idx % 4 !== 3);

src/core/operations/FangURL.mjs

@@ -0,0 +1,78 @@
+/**
+ * @author arnydo [github@arnydo.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * FangURL operation
+ */
+class FangURL extends Operation {
+
+    /**
+     * FangURL constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fang URL";
+        this.module = "Default";
+        this.description = "Takes a 'Defanged' Universal Resource Locator (URL) and 'Fangs' it. Meaning, it removes the alterations (defanged) that render it useless so that it can be used again.";
+        this.infoURL = "https://isc.sans.edu/forums/diary/Defang+all+the+things/22744/";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Restore [.]",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore hxxp",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Restore ://",
+                type: "boolean",
+                value: true
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [dots, http, slashes] = args;
+
+        input = fangURL(input, dots, http, slashes);
+
+        return input;
+    }
+
+}
+
+
+/**
+ * Defangs a given URL
+ *
+ * @param {string} url
+ * @param {boolean} dots
+ * @param {boolean} http
+ * @param {boolean} slashes
+ * @returns {string}
+ */
+function fangURL(url, dots, http, slashes) {
+    if (dots) url = url.replace(/\[\.\]/g, ".");
+    if (http) url = url.replace(/hxxp/g, "http");
+    if (slashes) url = url.replace(/\[:\/\/\]/g, "://");
+
+    return url;
+}
+
+export default FangURL;

src/core/operations/FernetDecrypt.mjs

@@ -0,0 +1,63 @@
+/**
+ * @author Karsten Silkenbäumer [github.com/kassi]
+ * @copyright Karsten Silkenbäumer 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import fernet from "fernet";
+
+/**
+ * FernetDecrypt operation
+ */
+class FernetDecrypt extends Operation {
+    /**
+     * FernetDecrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fernet Decrypt";
+        this.module = "Default";
+        this.description = "Fernet is a symmetric encryption method which makes sure that the message encrypted cannot be manipulated/read without the key. It uses URL safe encoding for the keys. Fernet uses 128-bit AES in CBC mode and PKCS7 padding, with HMAC using SHA256 for authentication. The IV is created from os.random().<br><br><b>Key:</b> The key must be 32 bytes (256 bits) encoded with Base64.";
+        this.infoURL = "https://asecuritysite.com/encryption/fer";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "string",
+                "value": ""
+            },
+        ];
+        this.patterns = [
+            {
+                match: "^[A-Z\\d\\-_=]{20,}$",
+                flags: "i",
+                args: []
+            },
+        ];
+    }
+    /**
+     * @param {String} input
+     * @param {Object[]} args
+     * @returns {String}
+     */
+    run(input, args) {
+        const [secretInput] = args;
+        try {
+            const secret = new fernet.Secret(secretInput);
+            const token = new fernet.Token({
+                secret: secret,
+                token: input,
+                ttl: 0
+            });
+            return token.decode();
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+}
+
+export default FernetDecrypt;

src/core/operations/FernetEncrypt.mjs

@@ -0,0 +1,54 @@
+/**
+ * @author Karsten Silkenbäumer [github.com/kassi]
+ * @copyright Karsten Silkenbäumer 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import fernet from "fernet";
+
+/**
+ * FernetEncrypt operation
+ */
+class FernetEncrypt extends Operation {
+    /**
+     * FernetEncrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fernet Encrypt";
+        this.module = "Default";
+        this.description = "Fernet is a symmetric encryption method which makes sure that the message encrypted cannot be manipulated/read without the key. It uses URL safe encoding for the keys. Fernet uses 128-bit AES in CBC mode and PKCS7 padding, with HMAC using SHA256 for authentication. The IV is created from os.random().<br><br><b>Key:</b> The key must be 32 bytes (256 bits) encoded with Base64.";
+        this.infoURL = "https://asecuritysite.com/encryption/fer";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "string",
+                "value": ""
+            },
+        ];
+    }
+    /**
+     * @param {String} input
+     * @param {Object[]} args
+     * @returns {String}
+     */
+    run(input, args) {
+        const [secretInput] = args;
+        try {
+            const secret = new fernet.Secret(secretInput);
+            const token = new fernet.Token({
+                secret: secret,
+            });
+            return token.encode(input);
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+}
+
+export default FernetEncrypt;

src/core/operations/FileTree.mjs

@@ -0,0 +1,94 @@
+/**
+ * @author sw5678
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import {INPUT_DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * Unique operation
+ */
+class FileTree extends Operation {
+
+    /**
+     * Unique constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "File Tree";
+        this.module = "Default";
+        this.description = "Creates a file tree from a list of file paths (similar to the tree command in Linux)";
+        this.infoURL = "https://wikipedia.org/wiki/Tree_(command)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "File Path Delimiter",
+                type: "binaryString",
+                value: "/"
+            },
+            {
+                name: "Delimiter",
+                type: "option",
+                value: INPUT_DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+
+        // Set up arrow and pipe for nice output display
+        const ARROW = "|---";
+        const PIPE = "|   ";
+
+        // Get args from input
+        const fileDelim = args[0];
+        const entryDelim = Utils.charRep(args[1]);
+
+        // Store path to print
+        const completedList = [];
+        const printList = [];
+
+        // Loop through all entries
+        const filePaths = input.split(entryDelim).unique().sort();
+        for (let i = 0; i < filePaths.length; i++) {
+            // Split by file delimiter
+            let path = filePaths[i].split(fileDelim);
+
+            if (path[0] === "") {
+                path = path.slice(1, path.length);
+            }
+
+            for (let j = 0; j < path.length; j++) {
+                let printLine;
+                let key;
+                if (j === 0) {
+                    printLine = path[j];
+                    key = path[j];
+                } else {
+                    printLine = PIPE.repeat(j-1) + ARROW + path[j];
+                    key = path.slice(0, j+1).join("/");
+                }
+
+                // Check to see we have already added that path
+                if (!completedList.includes(key)) {
+                    completedList.push(key);
+                    printList.push(printLine);
+                }
+            }
+        }
+        return printList.join("\n");
+    }
+
+}
+
+export default FileTree;

src/core/operations/FlipImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Flip Image operation
@@ -52,7 +51,7 @@ class FlipImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -70,9 +69,9 @@ class FlipImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/FrequencyDistribution.mjs

@@ -91,7 +91,7 @@ Number of bytes not represented: ${256 - freq.bytesRepresented}
 
 <script>
     var canvas = document.getElementById("chart-area"),
-        parentRect = canvas.parentNode.getBoundingClientRect(),
+        parentRect = canvas.closest(".cm-scroller").getBoundingClientRect(),
         scores = ${JSON.stringify(freq.percentages)};
 
     canvas.width = parentRect.width * 0.95;

src/core/operations/FromBCD.mjs

@@ -84,7 +84,7 @@ class FromBCD extends Operation {
                 break;
             case "Raw":
             default:
-                byteArray = Utils.strToByteArray(input);
+                byteArray = new Uint8Array(Utils.strToArrayBuffer(input));
                 byteArray.forEach(b => {
                     nibbles.push(b >>> 4);
                     nibbles.push(b & 15);

src/core/operations/FromBase32.mjs

@@ -6,6 +6,8 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
+import {ALPHABET_OPTIONS} from "../lib/Base32.mjs";
+
 
 /**
  * From Base32 operation
@@ -27,8 +29,8 @@ class FromBase32 extends Operation {
         this.args = [
             {
                 name: "Alphabet",
-                type: "binaryString",
-                value: "A-Z2-7="
+                type: "editableOption",
+                value: ALPHABET_OPTIONS
             },
             {
                 name: "Remove non-alphabet chars",
@@ -41,6 +43,11 @@ class FromBase32 extends Operation {
                 pattern: "^(?:[A-Z2-7]{8})+(?:[A-Z2-7]{2}={6}|[A-Z2-7]{4}={4}|[A-Z2-7]{5}={3}|[A-Z2-7]{7}={1})?$",
                 flags: "",
                 args: ["A-Z2-7=", false]
+            },
+            {
+                pattern: "^(?:[0-9A-V]{8})+(?:[0-9A-V]{2}={6}|[0-9A-V]{4}={4}|[0-9A-V]{5}={3}|[0-9A-V]{7}={1})?$",
+                flags: "",
+                args: ["0-9A-V=", false]
             }
         ];
     }
@@ -96,3 +103,4 @@ class FromBase32 extends Operation {
 }
 
 export default FromBase32;
+

src/core/operations/FromBase58.mjs

@@ -60,7 +60,7 @@ class FromBase58 extends Operation {
     run(input, args) {
         let alphabet = args[0] || ALPHABET_OPTIONS[0].value;
         const removeNonAlphaChars = args[1] === undefined ? true : args[1],
-            result = [0];
+            result = [];
 
         alphabet = Utils.expandAlphRange(alphabet).join("");
 
@@ -87,11 +87,9 @@ class FromBase58 extends Operation {
                 }
             }
 
-            let carry = result[0] * 58 + index;
-            result[0] = carry & 0xFF;
-            carry = carry >> 8;
+            let carry = index;
 
-            for (let i = 1; i < result.length; i++) {
+            for (let i = 0; i < result.length; i++) {
                 carry += result[i] * 58;
                 result[i] = carry & 0xFF;
                 carry = carry >> 8;

src/core/operations/FromBase92.mjs

@@ -0,0 +1,55 @@
+/**
+ * @author sg5506844 [sg5506844@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import { base92Ord } from "../lib/Base92.mjs";
+import Operation from "../Operation.mjs";
+
+/**
+ * From Base92 operation
+ */
+class FromBase92 extends Operation {
+    /**
+     * FromBase92 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Base92";
+        this.module = "Default";
+        this.description = "Base92 is a notation for encoding arbitrary byte data using a restricted set of symbols that can be conveniently used by humans and processed by computers.";
+        this.infoURL = "https://wikipedia.org/wiki/List_of_numeral_systems";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        const res = [];
+        let bitString = "";
+
+        for (let i = 0; i < input.length; i += 2) {
+            if (i + 1 !== input.length) {
+                const x = base92Ord(input[i]) * 91 + base92Ord(input[i + 1]);
+                bitString += x.toString(2).padStart(13, "0");
+            } else {
+                const x = base92Ord(input[i]);
+                bitString += x.toString(2).padStart(6, "0");
+            }
+            while (bitString.length >= 8) {
+                res.push(parseInt(bitString.slice(0, 8), 2));
+                bitString = bitString.slice(8);
+            }
+        }
+
+        return res;
+    }
+}
+
+export default FromBase92;

src/core/operations/FromCharcode.mjs

@@ -26,7 +26,7 @@ class FromCharcode extends Operation {
         this.description = "Converts unicode character codes back into text.<br><br>e.g. <code>0393 03b5 03b9 03ac 20 03c3 03bf 03c5</code> becomes <code>Γειά σου</code>";
         this.infoURL = "https://wikipedia.org/wiki/Plane_(Unicode)";
         this.inputType = "string";
-        this.outputType = "byteArray";
+        this.outputType = "ArrayBuffer";
         this.args = [
             {
                 "name": "Delimiter",
@@ -44,7 +44,7 @@ class FromCharcode extends Operation {
     /**
      * @param {string} input
      * @param {Object[]} args
-     * @returns {byteArray}
+     * @returns {ArrayBuffer}
      *
      * @throws {OperationError} if base out of range
      */
@@ -59,7 +59,7 @@ class FromCharcode extends Operation {
         }
 
         if (input.length === 0) {
-            return [];
+            return new ArrayBuffer;
         }
 
         if (base !== 16 && isWorkerEnvironment()) self.setOption("attemptHighlight", false);
@@ -77,7 +77,7 @@ class FromCharcode extends Operation {
         for (i = 0; i < bites.length; i++) {
             latin1 += Utils.chr(parseInt(bites[i], base));
         }
-        return Utils.strToByteArray(latin1);
+        return Utils.strToArrayBuffer(latin1);
     }
 
 }

src/core/operations/FromFloat.mjs

@@ -0,0 +1,78 @@
+/**
+ * @author tcode2k16 [tcode2k16@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import ieee754 from "ieee754";
+import {DELIM_OPTIONS} from "../lib/Delim.mjs";
+
+/**
+ * From Float operation
+ */
+class FromFloat extends Operation {
+
+    /**
+     * FromFloat constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Float";
+        this.module = "Default";
+        this.description = "Convert from IEEE754 Floating Point Numbers";
+        this.infoURL = "https://wikipedia.org/wiki/IEEE_754";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big Endian",
+                    "Little Endian"
+                ]
+            },
+            {
+                "name": "Size",
+                "type": "option",
+                "value": [
+                    "Float (4 bytes)",
+                    "Double (8 bytes)"
+                ]
+            },
+            {
+                "name": "Delimiter",
+                "type": "option",
+                "value": DELIM_OPTIONS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        if (input.length === 0) return [];
+
+        const [endianness, size, delimiterName] = args;
+        const delim = Utils.charRep(delimiterName || "Space");
+        const byteSize = size === "Double (8 bytes)" ? 8 : 4;
+        const isLE = endianness === "Little Endian";
+        const mLen = byteSize === 4 ? 23 : 52;
+        const floats = input.split(delim);
+
+        const output = new Array(floats.length*byteSize);
+        for (let i = 0; i < floats.length; i++) {
+            ieee754.write(output, parseFloat(floats[i]), i*byteSize, isLE, mLen, byteSize);
+        }
+        return output;
+    }
+
+}
+
+export default FromFloat;

src/core/operations/FromModhex.mjs

@@ -0,0 +1,84 @@
+/**
+ * @author linuxgemini [ilteris@asenkron.com.tr]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import { FROM_MODHEX_DELIM_OPTIONS, fromModhex } from "../lib/Modhex.mjs";
+
+/**
+ * From Modhex operation
+ */
+class FromModhex extends Operation {
+
+    /**
+     * FromModhex constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "From Modhex";
+        this.module = "Default";
+        this.description = "Converts a modhex byte string back into its raw value.";
+        this.infoURL = "https://en.wikipedia.org/wiki/YubiKey#ModHex";
+        this.inputType = "string";
+        this.outputType = "byteArray";
+        this.args = [
+            {
+                name: "Delimiter",
+                type: "option",
+                value: FROM_MODHEX_DELIM_OPTIONS
+            }
+        ];
+        this.checks = [
+            {
+                pattern: "^(?:[cbdefghijklnrtuv]{2})+$",
+                flags: "i",
+                args: ["None"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?: [cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["Space"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?:,[cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["Comma"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?:;[cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["Semi-colon"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?::[cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["Colon"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?:\\n[cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["Line feed"]
+            },
+            {
+                pattern: "^[cbdefghijklnrtuv]{2}(?:\\r\\n[cbdefghijklnrtuv]{2})*$",
+                flags: "i",
+                args: ["CRLF"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        const delim = args[0] || "Auto";
+        return fromModhex(input, delim, 2);
+    }
+}
+
+export default FromModhex;

src/core/operations/GOSTDecrypt.mjs

@@ -0,0 +1,151 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast, fromHex } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Decrypt operation
+ */
+class GOSTDecrypt extends Operation {
+
+    /**
+     * GOSTDecrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Decrypt";
+        this.module = "Ciphers";
+        this.description = "The GOST block cipher (Magma), defined in the standard GOST 28147-89 (RFC 5830), is a Soviet and Russian government standard symmetric key block cipher with a block size of 64 bits. The original standard, published in 1989, did not give the cipher any name, but the most recent revision of the standard, GOST R 34.12-2015 (RFC 7801, RFC 8891), specifies that it may be referred to as Magma. The GOST hash function is based on this cipher. The new standard also specifies a new 128-bit block cipher called Kuznyechik.<br><br>Developed in the 1970s, the standard had been marked 'Top Secret' and then downgraded to 'Secret' in 1990. Shortly after the dissolution of the USSR, it was declassified and it was released to the public in 1994. GOST 28147 was a Soviet alternative to the United States standard algorithm, DES. Thus, the two are very similar in structure.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "IV",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Hex", "Raw"]
+            },
+            {
+                name: "Output type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            },
+            {
+                name: "Block mode",
+                type: "option",
+                value: ["ECB", "CFB", "OFB", "CTR", "CBC"]
+            },
+            {
+                name: "Key meshing mode",
+                type: "option",
+                value: ["NO", "CP"]
+            },
+            {
+                name: "Padding",
+                type: "option",
+                value: ["NO", "PKCS5", "ZERO", "RANDOM", "BIT"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ivObj, inputType, outputType, version, sBox, blockMode, keyMeshing, padding] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "ES",
+            sBox: sBoxVal,
+            block: blockMode,
+            keyMeshing: keyMeshing,
+            padding: padding
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            if (iv) algorithm.iv = Hex.decode(iv);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = Hex.encode(cipher.decrypt(Hex.decode(key), Hex.decode(input)));
+
+            return outputType === "Hex" ? out : Utils.byteArrayToChars(fromHex(out));
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTDecrypt;

src/core/operations/GOSTEncrypt.mjs

@@ -0,0 +1,151 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast, fromHex } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Encrypt operation
+ */
+class GOSTEncrypt extends Operation {
+
+    /**
+     * GOSTEncrypt constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Encrypt";
+        this.module = "Ciphers";
+        this.description = "The GOST block cipher (Magma), defined in the standard GOST 28147-89 (RFC 5830), is a Soviet and Russian government standard symmetric key block cipher with a block size of 64 bits. The original standard, published in 1989, did not give the cipher any name, but the most recent revision of the standard, GOST R 34.12-2015 (RFC 7801, RFC 8891), specifies that it may be referred to as Magma. The GOST hash function is based on this cipher. The new standard also specifies a new 128-bit block cipher called Kuznyechik.<br><br>Developed in the 1970s, the standard had been marked 'Top Secret' and then downgraded to 'Secret' in 1990. Shortly after the dissolution of the USSR, it was declassified and it was released to the public in 1994. GOST 28147 was a Soviet alternative to the United States standard algorithm, DES. Thus, the two are very similar in structure.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "IV",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Output type",
+                type: "option",
+                value: ["Hex", "Raw"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            },
+            {
+                name: "Block mode",
+                type: "option",
+                value: ["ECB", "CFB", "OFB", "CTR", "CBC"]
+            },
+            {
+                name: "Key meshing mode",
+                type: "option",
+                value: ["NO", "CP"]
+            },
+            {
+                name: "Padding",
+                type: "option",
+                value: ["NO", "PKCS5", "ZERO", "RANDOM", "BIT"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ivObj, inputType, outputType, version, sBox, blockMode, keyMeshing, padding] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "ES",
+            sBox: sBoxVal,
+            block: blockMode,
+            keyMeshing: keyMeshing,
+            padding: padding
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            if (iv) algorithm.iv = Hex.decode(iv);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = Hex.encode(cipher.encrypt(Hex.decode(key), Hex.decode(input)));
+
+            return outputType === "Hex" ? out : Utils.byteArrayToChars(fromHex(out));
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTEncrypt;

src/core/operations/GOSTHash.mjs

@@ -7,7 +7,7 @@
 import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import GostDigest from "../vendor/gost/gostDigest.mjs";
-import {toHexFast} from "../lib/Hex.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
 
 /**
  * GOST hash operation
@@ -20,7 +20,7 @@ class GOSTHash extends Operation {
     constructor() {
         super();
 
-        this.name = "GOST hash";
+        this.name = "GOST Hash";
         this.module = "Hashing";
         this.description = "The GOST hash function, defined in the standards GOST R 34.11-94 and GOST 34.311-95 is a 256-bit cryptographic hash function. It was initially defined in the Russian national standard GOST R 34.11-94 <i>Information Technology – Cryptographic Information Security – Hash Function</i>. The equivalent standard used by other member-states of the CIS is GOST 34.311-95.<br><br>This function must not be confused with a different Streebog hash function, which is defined in the new revision of the standard GOST R 34.11-2012.<br><br>The GOST hash function is based on the GOST block cipher.";
         this.infoURL = "https://wikipedia.org/wiki/GOST_(hash_function)";
@@ -28,20 +28,30 @@ class GOSTHash extends Operation {
         this.outputType = "string";
         this.args = [
             {
-                "name": "S-Box",
-                "type": "option",
-                "value": [
-                    "D-A",
-                    "D-SC",
-                    "E-TEST",
-                    "E-A",
-                    "E-B",
-                    "E-C",
-                    "E-D",
-                    "E-SC",
-                    "E-Z",
-                    "D-TEST"
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1994)",
+                        off: [1],
+                        on: [2]
+                    },
+                    {
+                        name: "GOST R 34.11 (Streebog, 2012)",
+                        on: [1],
+                        off: [2]
+                    }
                 ]
+            },
+            {
+                name: "Digest length",
+                type: "option",
+                value: ["256", "512"]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
             }
         ];
     }
@@ -52,13 +62,23 @@ class GOSTHash extends Operation {
      * @returns {string}
      */
     run(input, args) {
+        const [version, length, sBox] = args;
+
+        const versionNum = version === "GOST 28147 (1994)" ? 1994 : 2012;
+        const algorithm = {
+            name: versionNum === 1994 ? "GOST 28147" : "GOST R 34.10",
+            version: versionNum,
+            mode: "HASH"
+        };
+
+        if (versionNum === 1994) {
+            algorithm.sBox = sBox;
+        } else {
+            algorithm.length = parseInt(length, 10);
+        }
+
         try {
-            const sBox = args[1];
-            const gostDigest = new GostDigest({
-                name: "GOST R 34.11",
-                version: 1994,
-                sBox: sBox
-            });
+            const gostDigest = new GostDigest(algorithm);
 
             return toHexFast(gostDigest.digest(input));
         } catch (err) {

src/core/operations/GOSTKeyUnwrap.mjs

@@ -0,0 +1,142 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast, fromHex } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Key Unwrap operation
+ */
+class GOSTKeyUnwrap extends Operation {
+
+    /**
+     * GOSTKeyUnwrap constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Key Unwrap";
+        this.module = "Ciphers";
+        this.description = "A decryptor for keys wrapped using one of the GOST block ciphers.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "User Key Material",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Hex", "Raw"]
+            },
+            {
+                name: "Output type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            },
+            {
+                name: "Key wrapping",
+                type: "option",
+                value: ["NO", "CP", "SC"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ukmObj, inputType, outputType, version, sBox, keyWrapping] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const ukm = toHexFast(Utils.convertToByteArray(ukmObj.string, ukmObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "KW",
+            sBox: sBoxVal,
+            keyWrapping: keyWrapping
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            algorithm.ukm = Hex.decode(ukm);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = Hex.encode(cipher.unwrapKey(Hex.decode(key), Hex.decode(input)));
+
+            return outputType === "Hex" ? out : Utils.byteArrayToChars(fromHex(out));
+        } catch (err) {
+            if (err.toString().includes("Invalid typed array length")) {
+                throw new OperationError("Incorrect input length. Must be a multiple of the block size.");
+            }
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTKeyUnwrap;

src/core/operations/GOSTKeyWrap.mjs

@@ -0,0 +1,142 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast, fromHex } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Key Wrap operation
+ */
+class GOSTKeyWrap extends Operation {
+
+    /**
+     * GOSTKeyWrap constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Key Wrap";
+        this.module = "Ciphers";
+        this.description = "A key wrapping algorithm for protecting keys in untrusted storage using one of the GOST block cipers.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "User Key Material",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Output type",
+                type: "option",
+                value: ["Hex", "Raw"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            },
+            {
+                name: "Key wrapping",
+                type: "option",
+                value: ["NO", "CP", "SC"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ukmObj, inputType, outputType, version, sBox, keyWrapping] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const ukm = toHexFast(Utils.convertToByteArray(ukmObj.string, ukmObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "KW",
+            sBox: sBoxVal,
+            keyWrapping: keyWrapping
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            algorithm.ukm = Hex.decode(ukm);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = Hex.encode(cipher.wrapKey(Hex.decode(key), Hex.decode(input)));
+
+            return outputType === "Hex" ? out : Utils.byteArrayToChars(fromHex(out));
+        } catch (err) {
+            if (err.toString().includes("Invalid typed array length")) {
+                throw new OperationError("Incorrect input length. Must be a multiple of the block size.");
+            }
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTKeyWrap;

src/core/operations/GOSTSign.mjs

@@ -0,0 +1,142 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast, fromHex } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Sign operation
+ */
+class GOSTSign extends Operation {
+
+    /**
+     * GOSTSign constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Sign";
+        this.module = "Ciphers";
+        this.description = "Sign a plaintext message using one of the GOST block ciphers.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "IV",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Output type",
+                type: "option",
+                value: ["Hex", "Raw"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            },
+            {
+                name: "MAC length",
+                type: "number",
+                value: 32,
+                min: 8,
+                max: 64,
+                step: 8
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ivObj, inputType, outputType, version, sBox, macLength] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "MAC",
+            sBox: sBoxVal,
+            macLength: macLength
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            if (iv) algorithm.iv = Hex.decode(iv);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = Hex.encode(cipher.sign(Hex.decode(key), Hex.decode(input)));
+
+            return outputType === "Hex" ? out : Utils.byteArrayToChars(fromHex(out));
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTSign;

src/core/operations/GOSTVerify.mjs

@@ -0,0 +1,136 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import { CryptoGost, GostEngine } from "@wavesenterprise/crypto-gost-js/index.js";
+
+/**
+ * GOST Verify operation
+ */
+class GOSTVerify extends Operation {
+
+    /**
+     * GOSTVerify constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "GOST Verify";
+        this.module = "Ciphers";
+        this.description = "Verify the signature of a plaintext message using one of the GOST block ciphers. Enter the signature in the MAC field.";
+        this.infoURL = "https://wikipedia.org/wiki/GOST_(block_cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Key",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "IV",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "MAC",
+                type: "toggleString",
+                value: "",
+                toggleValues: ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                name: "Input type",
+                type: "option",
+                value: ["Raw", "Hex"]
+            },
+            {
+                name: "Algorithm",
+                type: "argSelector",
+                value: [
+                    {
+                        name: "GOST 28147 (1989)",
+                        on: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
+                    {
+                        name: "GOST R 34.12 (Kuznyechik, 2015)",
+                        off: [5]
+                    }
+                ]
+            },
+            {
+                name: "sBox",
+                type: "option",
+                value: ["E-TEST", "E-A", "E-B", "E-C", "E-D", "E-SC", "E-Z", "D-TEST", "D-A", "D-SC"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [keyObj, ivObj, macObj, inputType, version, sBox] = args;
+
+        const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
+        const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
+        const mac = toHexFast(Utils.convertToByteArray(macObj.string, macObj.option));
+        input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
+
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
+        const sBoxVal = versionNum === 1989 ? sBox : null;
+
+        const algorithm = {
+            version: versionNum,
+            length: blockLength,
+            mode: "MAC",
+            sBox: sBoxVal,
+            macLength: mac.length * 4
+        };
+
+        try {
+            const Hex = CryptoGost.coding.Hex;
+            if (iv) algorithm.iv = Hex.decode(iv);
+
+            const cipher = GostEngine.getGostCipher(algorithm);
+            const out = cipher.verify(Hex.decode(key), Hex.decode(mac), Hex.decode(input));
+
+            return out ? "The signature matches" : "The signature does not match";
+        } catch (err) {
+            throw new OperationError(err);
+        }
+    }
+
+}
+
+export default GOSTVerify;

src/core/operations/GenerateAllHashes.mjs

@@ -27,9 +27,7 @@ import Fletcher16Checksum from "./Fletcher16Checksum.mjs";
 import Fletcher32Checksum from "./Fletcher32Checksum.mjs";
 import Fletcher64Checksum from "./Fletcher64Checksum.mjs";
 import Adler32Checksum from "./Adler32Checksum.mjs";
-import CRC8Checksum from "./CRC8Checksum.mjs";
-import CRC16Checksum from "./CRC16Checksum.mjs";
-import CRC32Checksum from "./CRC32Checksum.mjs";
+import CRCChecksum from "./CRCChecksum.mjs";
 import BLAKE2b from "./BLAKE2b.mjs";
 import BLAKE2s from "./BLAKE2s.mjs";
 import Streebog from "./Streebog.mjs";
@@ -108,7 +106,7 @@ class GenerateAllHashes extends Operation {
             {name: "BLAKE2s-256", algo: (new BLAKE2s), inputType: "arrayBuffer", params: ["256", "Hex", {string: "", option: "UTF8"}]},
             {name: "Streebog-256", algo: (new Streebog), inputType: "arrayBuffer", params: ["256"]},
             {name: "Streebog-512", algo: (new Streebog), inputType: "arrayBuffer", params: ["512"]},
-            {name: "GOST", algo: (new GOSTHash), inputType: "arrayBuffer", params: ["D-A"]},
+            {name: "GOST", algo: (new GOSTHash), inputType: "arrayBuffer", params: ["GOST 28147 (1994)", "256", "D-A"]},
             {name: "LM Hash", algo: (new LMHash), inputType: "str", params: []},
             {name: "NT Hash", algo: (new NTHash), inputType: "str", params: []},
             {name: "SSDEEP", algo: (new SSDEEP()), inputType: "str"},
@@ -120,9 +118,9 @@ class GenerateAllHashes extends Operation {
             {name: "Fletcher-32", algo: (new Fletcher32Checksum), inputType: "byteArray", params: []},
             {name: "Fletcher-64", algo: (new Fletcher64Checksum), inputType: "byteArray", params: []},
             {name: "Adler-32", algo: (new Adler32Checksum), inputType: "byteArray", params: []},
-            {name: "CRC-8", algo: (new CRC8Checksum), inputType: "arrayBuffer", params: ["CRC-8"]},
-            {name: "CRC-16", algo: (new CRC16Checksum), inputType: "arrayBuffer", params: []},
-            {name: "CRC-32", algo: (new CRC32Checksum), inputType: "arrayBuffer", params: []}
+            {name: "CRC-8", algo: (new CRCChecksum), inputType: "arrayBuffer", params: ["CRC-8"]},
+            {name: "CRC-16", algo: (new CRCChecksum), inputType: "arrayBuffer", params: ["CRC-16"]},
+            {name: "CRC-32", algo: (new CRCChecksum), inputType: "arrayBuffer", params: ["CRC-32"]}
         ];
     }
 

src/core/operations/GenerateDeBruijnSequence.mjs

@@ -0,0 +1,85 @@
+/**
+ * @author gchq77703 [gchq77703@gchq.gov.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Generate De Bruijn Sequence operation
+ */
+class GenerateDeBruijnSequence extends Operation {
+
+    /**
+     * GenerateDeBruijnSequence constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Generate De Bruijn Sequence";
+        this.module = "Default";
+        this.description = "Generates rolling keycode combinations given a certain alphabet size and key length.";
+        this.infoURL = "https://wikipedia.org/wiki/De_Bruijn_sequence";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Alphabet size (k)",
+                type: "number",
+                value: 2
+            },
+            {
+                name: "Key length (n)",
+                type: "number",
+                value: 3
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [k, n] = args;
+
+        if (k < 2 || k > 9) {
+            throw new OperationError("Invalid alphabet size, required to be between 2 and 9 (inclusive).");
+        }
+
+        if (n < 2) {
+            throw new OperationError("Invalid key length, required to be at least 2.");
+        }
+
+        if (Math.pow(k, n) > 50000) {
+            throw new OperationError("Too many permutations, please reduce k^n to under 50,000.");
+        }
+
+        const a = new Array(k * n).fill(0);
+        const sequence = [];
+
+        (function db(t = 1, p = 1) {
+            if (t > n) {
+                if (n % p !== 0) return;
+                for (let j = 1; j <= p; j++) {
+                    sequence.push(a[j]);
+                }
+                return;
+            }
+
+            a[t] = a[t - p];
+            db(t + 1, p);
+            for (let j = a[t - p] + 1; j < k; j++) {
+                a[t] = j;
+                db(t + 1, t);
+            }
+        })();
+
+        return sequence.join("");
+    }
+}
+
+export default GenerateDeBruijnSequence;

src/core/operations/GenerateECDSAKeyPair.mjs

@@ -0,0 +1,102 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import { cryptNotice } from "../lib/Crypt.mjs";
+import r from "jsrsasign";
+
+/**
+ * Generate ECDSA Key Pair operation
+ */
+class GenerateECDSAKeyPair extends Operation {
+
+    /**
+     * GenerateECDSAKeyPair constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Generate ECDSA Key Pair";
+        this.module = "Ciphers";
+        this.description = `Generate an ECDSA key pair with a given Curve.<br><br>${cryptNotice}`;
+        this.infoURL = "https://wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Elliptic Curve",
+                type: "option",
+                value: [
+                    "P-256",
+                    "P-384",
+                    "P-521"
+                ]
+            },
+            {
+                name: "Output Format",
+                type: "option",
+                value: [
+                    "PEM",
+                    "DER",
+                    "JWK"
+                ]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [curveName, outputFormat] = args;
+
+        return new Promise((resolve, reject) => {
+            let internalCurveName;
+            switch (curveName) {
+                case "P-256":
+                    internalCurveName = "secp256r1";
+                    break;
+                case "P-384":
+                    internalCurveName = "secp384r1";
+                    break;
+                case "P-521":
+                    internalCurveName = "secp521r1";
+                    break;
+            }
+            const keyPair = r.KEYUTIL.generateKeypair("EC", internalCurveName);
+
+            let pubKey;
+            let privKey;
+            let result;
+            switch (outputFormat) {
+                case "PEM":
+                    pubKey = r.KEYUTIL.getPEM(keyPair.pubKeyObj).replace(/\r/g, "");
+                    privKey = r.KEYUTIL.getPEM(keyPair.prvKeyObj, "PKCS8PRV").replace(/\r/g, "");
+                    result = pubKey + "\n" + privKey;
+                    break;
+                case "DER":
+                    result = keyPair.prvKeyObj.prvKeyHex;
+                    break;
+                case "JWK":
+                    pubKey = r.KEYUTIL.getJWKFromKey(keyPair.pubKeyObj);
+                    pubKey.key_ops = ["verify"]; // eslint-disable-line camelcase
+                    pubKey.kid = "PublicKey";
+                    privKey = r.KEYUTIL.getJWKFromKey(keyPair.prvKeyObj);
+                    privKey.key_ops = ["sign"]; // eslint-disable-line camelcase
+                    privKey.kid = "PrivateKey";
+                    result = JSON.stringify({keys: [privKey, pubKey]}, null, 4);
+                    break;
+            }
+
+            resolve(result);
+        });
+    }
+
+}
+
+export default GenerateECDSAKeyPair;

src/core/operations/GenerateHOTP.mjs

@@ -5,16 +5,14 @@
  */
 
 import Operation from "../Operation.mjs";
-import otp from "otp";
-import ToBase32 from "./ToBase32.mjs";
+import * as OTPAuth from "otpauth";
 
 /**
  * Generate HOTP operation
  */
 class GenerateHOTP extends Operation {
-
     /**
-     * GenerateHOTP constructor
+     *
      */
     constructor() {
         super();
@@ -31,11 +29,6 @@ class GenerateHOTP extends Operation {
                 "type": "string",
                 "value": ""
             },
-            {
-                "name": "Key size",
-                "type": "number",
-                "value": 32
-            },
             {
                 "name": "Code length",
                 "type": "number",
@@ -50,21 +43,26 @@ class GenerateHOTP extends Operation {
     }
 
     /**
-     * @param {ArrayBuffer} input
-     * @param {Object[]} args
-     * @returns {string}
+     *
      */
     run(input, args) {
-        const otpObj = otp({
-            name: args[0],
-            keySize: args[1],
-            codeLength: args[2],
-            secret: (new ToBase32).run(input, []).split("=")[0],
-        });
-        const counter = args[3];
-        return `URI: ${otpObj.hotpURL}\n\nPassword: ${otpObj.hotp(counter)}`;
-    }
+        const secretStr = new TextDecoder("utf-8").decode(input).trim();
+        const secret = secretStr ? secretStr.toUpperCase().replace(/\s+/g, "") : "";
 
+        const hotp = new OTPAuth.HOTP({
+            issuer: "",
+            label: args[0],
+            algorithm: "SHA1",
+            digits: args[1],
+            counter: args[2],
+            secret: OTPAuth.Secret.fromBase32(secret)
+        });
+
+        const uri = hotp.toString();
+        const code = hotp.generate();
+
+        return `URI: ${uri}\n\nPassword: ${code}`;
+    }
 }
 
 export default GenerateHOTP;

src/core/operations/GenerateImage.mjs

@@ -10,8 +10,7 @@ import Utils from "../Utils.mjs";
 import {isImage} from "../lib/FileType.mjs";
 import {toBase64} from "../lib/Base64.mjs";
 import {isWorkerEnvironment} from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Generate Image operation
@@ -82,7 +81,7 @@ class GenerateImage extends Operation {
         }
 
         const height = Math.ceil(input.length / bytesPerPixel / width);
-        const image = await new jimp(width, height, (err, image) => {});
+        const image = await new Jimp(width, height, (err, image) => {});
 
         if (isWorkerEnvironment())
             self.sendStatusMessage("Generating image from data...");
@@ -96,7 +95,7 @@ class GenerateImage extends Operation {
                     const y = Math.floor(index / width);
 
                     const value = curByte[k] === "0" ? 0xFF : 0x00;
-                    const pixel = jimp.rgbaToInt(value, value, value, 0xFF);
+                    const pixel = Jimp.rgbaToInt(value, value, value, 0xFF);
                     image.setPixelColor(pixel, x, y);
                 }
             }
@@ -140,7 +139,7 @@ class GenerateImage extends Operation {
                 }
 
                 try {
-                    const pixel = jimp.rgbaToInt(red, green, blue, alpha);
+                    const pixel = Jimp.rgbaToInt(red, green, blue, alpha);
                     image.setPixelColor(pixel, x, y);
                 } catch (err) {
                     throw new OperationError(`Error while generating image from pixel values. (${err})`);
@@ -152,11 +151,11 @@ class GenerateImage extends Operation {
             if (isWorkerEnvironment())
                 self.sendStatusMessage("Scaling image...");
 
-            image.scaleToFit(width*scale, height*scale, jimp.RESIZE_NEAREST_NEIGHBOR);
+            image.scaleToFit(width*scale, height*scale, Jimp.RESIZE_NEAREST_NEIGHBOR);
         }
 
         try {
-            const imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+            const imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             return imageBuffer.buffer;
         } catch (err) {
             throw new OperationError(`Error generating image. (${err})`);

src/core/operations/GenerateTOTP.mjs

@@ -5,20 +5,17 @@
  */
 
 import Operation from "../Operation.mjs";
-import otp from "otp";
-import ToBase32 from "./ToBase32.mjs";
+import * as OTPAuth from "otpauth";
 
 /**
  * Generate TOTP operation
  */
 class GenerateTOTP extends Operation {
-
     /**
-     * GenerateTOTP constructor
+     *
      */
     constructor() {
         super();
-
         this.name = "Generate TOTP";
         this.module = "Default";
         this.description = "The Time-based One-Time Password algorithm (TOTP) is an algorithm that computes a one-time password from a shared secret key and the current time. It has been adopted as Internet Engineering Task Force standard RFC 6238, is the cornerstone of Initiative For Open Authentication (OAUTH), and is used in a number of two-factor authentication systems. A TOTP is an HOTP where the counter is the current time.<br><br>Enter the secret as the input or leave it blank for a random secret to be generated. T0 and T1 are in seconds.";
@@ -31,11 +28,6 @@ class GenerateTOTP extends Operation {
                 "type": "string",
                 "value": ""
             },
-            {
-                "name": "Key size",
-                "type": "number",
-                "value": 32
-            },
             {
                 "name": "Code length",
                 "type": "number",
@@ -55,22 +47,27 @@ class GenerateTOTP extends Operation {
     }
 
     /**
-     * @param {ArrayBuffer} input
-     * @param {Object[]} args
-     * @returns {string}
+     *
      */
     run(input, args) {
-        const otpObj = otp({
-            name: args[0],
-            keySize: args[1],
-            codeLength: args[2],
-            secret: (new ToBase32).run(input, []).split("=")[0],
-            epoch: args[3],
-            timeSlice: args[4]
-        });
-        return `URI: ${otpObj.totpURL}\n\nPassword: ${otpObj.totp()}`;
-    }
+        const secretStr = new TextDecoder("utf-8").decode(input).trim();
+        const secret = secretStr ? secretStr.toUpperCase().replace(/\s+/g, "") : "";
 
+        const totp = new OTPAuth.TOTP({
+            issuer: "",
+            label: args[0],
+            algorithm: "SHA1",
+            digits: args[1],
+            period: args[3],
+            epoch: args[2] * 1000, // Convert seconds to milliseconds
+            secret: OTPAuth.Secret.fromBase32(secret)
+        });
+
+        const uri = totp.toString();
+        const code = totp.generate();
+
+        return `URI: ${uri}\n\nPassword: ${code}`;
+    }
 }
 
 export default GenerateTOTP;

src/core/operations/HammingDistance.mjs

@@ -68,8 +68,8 @@ class HammingDistance extends Operation {
             samples[0] = fromHex(samples[0]);
             samples[1] = fromHex(samples[1]);
         } else {
-            samples[0] = Utils.strToByteArray(samples[0]);
-            samples[1] = Utils.strToByteArray(samples[1]);
+            samples[0] = new Uint8Array(Utils.strToArrayBuffer(samples[0]));
+            samples[1] = new Uint8Array(Utils.strToArrayBuffer(samples[1]));
         }
 
         let dist = 0;

src/core/operations/IPv6TransitionAddresses.mjs

@@ -0,0 +1,209 @@
+/**
+ * @author jb30795 [jb30795@proton.me]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * IPv6 Transition Addresses operation
+ */
+class IPv6TransitionAddresses extends Operation {
+
+    /**
+     * IPv6TransitionAddresses constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "IPv6 Transition Addresses";
+        this.module = "Default";
+        this.description = "Converts IPv4 addresses to their IPv6 Transition addresses. IPv6 Transition addresses can also be converted back into their original IPv4 address. MAC addresses can also be converted into the EUI-64 format, this can them be appended to your IPv6 /64 range to obtain a full /128 address.<br><br>Transition technologies enable translation between IPv4 and IPv6 addresses or tunneling to allow traffic to pass through the incompatible network, allowing the two standards to coexist.<br><br>Only /24 ranges and currently handled. Remove headers to easily copy out results.";
+        this.infoURL = "https://wikipedia.org/wiki/IPv6_transition_mechanism";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+	    {
+                "name": "Ignore ranges",
+                "type": "boolean",
+	        "value": true
+	    },
+            {
+                "name": "Remove headers",
+                "type": "boolean",
+                "value": false
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const XOR = {"0": "2", "1": "3", "2": "0", "3": "1", "4": "6", "5": "7", "6": "4", "7": "5", "8": "a", "9": "b", "a": "8", "b": "9", "c": "e", "d": "f", "e": "c", "f": "d"};
+
+        /**
+	 * Function to convert to hex
+	 */
+        function hexify(octet) {
+            return Number(octet).toString(16).padStart(2, "0");
+        }
+
+        /**
+	 * Function to convert Hex to Int
+	 */
+        function intify(hex) {
+            return parseInt(hex, 16);
+        }
+
+        /**
+	 * Function converts IPv4 to IPv6 Transtion address
+	 */
+        function ipTransition(input, range) {
+            let output = "";
+            const HEXIP = input.split(".");
+
+            /**
+	     * 6to4
+	     */
+            if (!args[1]) {
+                output += "6to4: ";
+            }
+            output += "2002:" + hexify(HEXIP[0]) + hexify(HEXIP[1]) + ":" + hexify(HEXIP[2]);
+            if (range) {
+                output += "00::/40\n";
+            } else {
+                output += hexify(HEXIP[3]) + "::/48\n";
+            }
+
+            /**
+	     * Mapped
+	     */
+            if (!args[1]) {
+                output += "IPv4 Mapped: ";
+            }
+            output += "::ffff:" + hexify(HEXIP[0]) + hexify(HEXIP[1]) + ":" + hexify(HEXIP[2]);
+            if (range) {
+                output += "00/120\n";
+            } else {
+                output += hexify(HEXIP[3]) + "\n";
+            }
+
+            /**
+	     * Translated
+	     */
+            if (!args[1]) {
+                output += "IPv4 Translated: ";
+            }
+            output += "::ffff:0:" + hexify(HEXIP[0]) + hexify(HEXIP[1]) + ":" + hexify(HEXIP[2]);
+            if (range) {
+                output += "00/120\n";
+            } else {
+                output += hexify(HEXIP[3]) + "\n";
+            }
+
+            /**
+	     * Nat64
+	     */
+            if (!args[1]) {
+                output += "Nat 64: ";
+            }
+            output += "64:ff9b::" + hexify(HEXIP[0]) + hexify(HEXIP[1]) + ":" + hexify(HEXIP[2]);
+            if (range) {
+                output += "00/120\n";
+            } else {
+                output += hexify(HEXIP[3]) + "\n";
+            }
+
+            return output;
+        }
+
+        /**
+	 * Convert MAC to EUI-64
+	 */
+        function macTransition(input) {
+            let output = "";
+            const MACPARTS = input.split(":");
+            if (!args[1]) {
+                output += "EUI-64 Interface ID: ";
+            }
+            const MAC = MACPARTS[0] + MACPARTS[1] + ":" + MACPARTS[2] + "ff:fe" + MACPARTS[3] + ":" + MACPARTS[4] + MACPARTS[5];
+            output += MAC.slice(0, 1) + XOR[MAC.slice(1, 2)] + MAC.slice(2);
+
+            return output;
+        }
+
+
+        /**
+	 * Convert IPv6 address to its original IPv4 or MAC address
+	 */
+        function unTransition(input) {
+            let output = "";
+            let hextets = "";
+
+            /**
+	     * 6to4
+	     */
+            if (input.startsWith("2002:")) {
+                if (!args[1]) {
+                    output += "IPv4: ";
+                }
+                output += String(intify(input.slice(5, 7))) + "." + String(intify(input.slice(7, 9)))+ "." + String(intify(input.slice(10, 12)))+ "." + String(intify(input.slice(12, 14))) + "\n";
+            } else if (input.startsWith("::ffff:") || input.startsWith("0000:0000:0000:0000:0000:ffff:") || input.startsWith("::ffff:0000:") || input.startsWith("0000:0000:0000:0000:ffff:0000:") || input.startsWith("64:ff9b::") || input.startsWith("0064:ff9b:0000:0000:0000:0000:")) {
+		/**
+		 * Mapped/Translated/Nat64
+		 */
+                hextets = /:([0-9a-z]{1,4}):[0-9a-z]{1,4}$/.exec(input)[1].padStart(4, "0") + /:([0-9a-z]{1,4})$/.exec(input)[1].padStart(4, "0");
+                if (!args[1]) {
+                    output += "IPv4: ";
+                }
+                output += intify(hextets.slice(-8, -7) +  hextets.slice(-7, -6)) + "." +intify(hextets.slice(-6, -5) +  hextets.slice(-5, -4)) + "." +intify(hextets.slice(-4, -3) +  hextets.slice(-3, -2)) + "." +intify(hextets.slice(-2, -1) +  hextets.slice(-1,)) + "\n";
+            } else if (input.slice(-12, -7).toUpperCase() === "FF:FE") {
+		/**
+		 * EUI-64
+		 */
+                if (!args[1]) {
+                    output += "Mac Address: ";
+                }
+                const MAC = (input.slice(-19, -17) + ":" + input.slice(-17, -15) + ":" + input.slice(-14, -12) + ":" + input.slice(-7, -5) + ":" + input.slice(-4, -2) + ":" + input.slice(-2,)).toUpperCase();
+                output += MAC.slice(0, 1) + XOR[MAC.slice(1, 2)] + MAC.slice(2) + "\n";
+            }
+
+            return output;
+        }
+
+
+        /**
+	 * Main
+	 */
+        let output = "";
+        let inputs = input.split("\n");
+        // Remove blank rows
+        inputs = inputs.filter(Boolean);
+
+        for (let i = 0; i < inputs.length; i++) {
+            // if ignore ranges is checked and input is a range, skip
+            if ((args[0] && !inputs[i].includes("/")) || (!args[0])) {
+                if (/^[0-9]{1,3}(?:\.[0-9]{1,3}){3}$/.test(inputs[i])) {
+                    output += ipTransition(inputs[i], false);
+                } else if (/\/24$/.test(inputs[i])) {
+                    output += ipTransition(inputs[i], true);
+                } else if (/^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$/.test(inputs[i])) {
+                    output += macTransition(inputs[i]);
+                } else if (/^((?:[0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,7}:|(?:[0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|(?:[0-9a-fA-F]{1,4}:){1,5}(?::[0-9a-fA-F]{1,4}){1,2}|(?:[0-9a-fA-F]{1,4}:){1,4}(?::[0-9a-fA-F]{1,4}){1,3}|(?:[0-9a-fA-F]{1,4}:){1,3}(?::[0-9a-fA-F]{1,4}){1,4}|(?:[0-9a-fA-F]{1,4}:){1,2}(?::[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:(?:(?::[0-9a-fA-F]{1,4}){1,6})|:(?:(?::[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(?::[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(?:ffff(?::0{1,4}){0,1}:){0,1}(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])|(?:[0-9a-fA-F]{1,4}:){1,4}:(?:(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(?:25[0-5]|(?:2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/.test(inputs[i])) {
+                    output += unTransition(inputs[i]);
+                } else {
+                    output = "Enter compressed or expanded IPv6 address, IPv4 address or MAC Address.";
+                }
+            }
+        }
+
+        return output;
+    }
+
+}
+
+export default IPv6TransitionAddresses;

src/core/operations/ImageBrightnessContrast.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Image Brightness / Contrast operation
@@ -61,7 +60,7 @@ class ImageBrightnessContrast extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -79,9 +78,9 @@ class ImageBrightnessContrast extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/ImageFilter.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Image Filter operation
@@ -55,7 +54,7 @@ class ImageFilter extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -70,9 +69,9 @@ class ImageFilter extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/ImageHueSaturationLightness.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Image Hue/Saturation/Lightness operation
@@ -69,7 +68,7 @@ class ImageHueSaturationLightness extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -107,9 +106,9 @@ class ImageHueSaturationLightness extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/ImageOpacity.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Image Opacity operation
@@ -54,7 +53,7 @@ class ImageOpacity extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -65,9 +64,9 @@ class ImageOpacity extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/IndexOfCoincidence.mjs

@@ -78,7 +78,7 @@ The graph shows the IC of the input data. A low IC generally means that the text
 
 <script type='application/javascript'>
   var canvas = document.getElementById("chart-area"),
-      parentRect = canvas.parentNode.getBoundingClientRect(),
+      parentRect = canvas.closest(".cm-scroller").getBoundingClientRect(),
       ic = ${ic};
 
   canvas.width = parentRect.width * 0.95;

src/core/operations/InvertImage.mjs

@@ -9,8 +9,7 @@ import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Invert Image operation
@@ -45,7 +44,7 @@ class InvertImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error loading image. (${err})`);
         }
@@ -56,9 +55,9 @@ class InvertImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/JA4Fingerprint.mjs

@@ -0,0 +1,73 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import {toJA4} from "../lib/JA4.mjs";
+
+/**
+ * JA4 Fingerprint operation
+ */
+class JA4Fingerprint extends Operation {
+
+    /**
+     * JA4Fingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JA4 Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a JA4 fingerprint to help identify TLS clients based on hashing together values from the Client Hello.<br><br>Input: A hex stream of the TLS or QUIC Client Hello packet application layer.";
+        this.infoURL = "https://medium.com/foxio/ja4-network-fingerprinting-9376fe9ca637";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input format",
+                type: "option",
+                value: ["Hex", "Base64", "Raw"]
+            },
+            {
+                name: "Output format",
+                type: "option",
+                value: ["JA4", "JA4 Original Rendering", "JA4 Raw", "JA4 Raw Original Rendering", "All"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [inputFormat, outputFormat] = args;
+        input = Utils.convertToByteArray(input, inputFormat);
+        const ja4 = toJA4(new Uint8Array(input));
+
+        // Output
+        switch (outputFormat) {
+            case "JA4":
+                return ja4.JA4;
+            case "JA4 Original Rendering":
+                return ja4.JA4_o;
+            case "JA4 Raw":
+                return ja4.JA4_r;
+            case "JA4 Raw Original Rendering":
+                return ja4.JA4_ro;
+            case "All":
+            default:
+                return `JA4:    ${ja4.JA4}
+JA4_o:  ${ja4.JA4_o}
+JA4_r:  ${ja4.JA4_r}
+JA4_ro: ${ja4.JA4_ro}`;
+        }
+    }
+
+}
+
+export default JA4Fingerprint;

src/core/operations/JA4ServerFingerprint.mjs

@@ -0,0 +1,66 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import {toJA4S} from "../lib/JA4.mjs";
+
+/**
+ * JA4Server Fingerprint operation
+ */
+class JA4ServerFingerprint extends Operation {
+
+    /**
+     * JA4ServerFingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JA4Server Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a JA4Server Fingerprint (JA4S) to help identify TLS servers or sessions based on hashing together values from the Server Hello.<br><br>Input: A hex stream of the TLS or QUIC Server Hello packet application layer.";
+        this.infoURL = "https://medium.com/foxio/ja4-network-fingerprinting-9376fe9ca637";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input format",
+                type: "option",
+                value: ["Hex", "Base64", "Raw"]
+            },
+            {
+                name: "Output format",
+                type: "option",
+                value: ["JA4S", "JA4S Raw", "Both"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [inputFormat, outputFormat] = args;
+        input = Utils.convertToByteArray(input, inputFormat);
+        const ja4s = toJA4S(new Uint8Array(input));
+
+        // Output
+        switch (outputFormat) {
+            case "JA4S":
+                return ja4s.JA4S;
+            case "JA4S Raw":
+                return ja4s.JA4S_r;
+            case "Both":
+            default:
+                return `JA4S:   ${ja4s.JA4S}\nJA4S_r: ${ja4s.JA4S_r}`;
+        }
+    }
+
+}
+
+export default JA4ServerFingerprint;

src/core/operations/JPathExpression.mjs

@@ -35,12 +35,6 @@ class JPathExpression extends Operation {
                 name: "Result delimiter",
                 type: "binaryShortString",
                 value: "\\n"
-            },
-            {
-                name: "Prevent eval",
-                type: "boolean",
-                value: true,
-                description: "Evaluated expressions are disabled by default for security reasons"
             }
         ];
     }
@@ -51,7 +45,7 @@ class JPathExpression extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const [query, delimiter, preventEval] = args;
+        const [query, delimiter] = args;
         let results, jsonObj;
 
         try {
@@ -63,8 +57,7 @@ class JPathExpression extends Operation {
         try {
             results = JSONPath({
                 path: query,
-                json: jsonObj,
-                preventEval: preventEval
+                json: jsonObj
             });
         } catch (err) {
             throw new OperationError(`Invalid JPath expression: ${err.message}`);

src/core/operations/JSONtoYAML.mjs

@@ -0,0 +1,46 @@
+/**
+ * @author ccarpo [ccarpo@gmx.net]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import YAML from "yaml";
+
+/**
+ * JSON to YAML operation
+ */
+class JSONtoYAML extends Operation {
+
+    /**
+     * JSONtoYAML constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JSON to YAML";
+        this.module = "Default";
+        this.description = "Format a JSON object into YAML";
+        this.infoURL = "https://en.wikipedia.org/wiki/YAML";
+        this.inputType = "JSON";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        try {
+            return YAML.stringify(input);
+        } catch (err) {
+            throw new OperationError("Test");
+        }
+    }
+
+}
+
+export default JSONtoYAML;

src/core/operations/JWKToPem.mjs

@@ -0,0 +1,80 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import r from "jsrsasign";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * PEM to JWK operation
+ */
+class PEMToJWK extends Operation {
+
+    /**
+     * PEMToJWK constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JWK to PEM";
+        this.module = "PublicKey";
+        this.description = "Converts Keys in JSON Web Key format to PEM format (PKCS#8).";
+        this.infoURL = "https://datatracker.ietf.org/doc/html/rfc7517";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+        this.checks = [
+            {
+                "pattern": "\"kty\":\\s*\"(EC|RSA)\"",
+                "flags": "gm",
+                "args": []
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const inputJson = JSON.parse(input);
+
+        let keys = [];
+        if (Array.isArray(inputJson)) {
+            // list of keys => transform all keys
+            keys = inputJson;
+        } else if (Array.isArray(inputJson.keys)) {
+            // JSON Web Key Set => transform all keys
+            keys = inputJson.keys;
+        } else if (typeof inputJson === "object") {
+            // single key
+            keys.push(inputJson);
+        } else {
+            throw new OperationError("Input is not a JSON Web Key");
+        }
+
+        let output = "";
+        for (let i=0; i<keys.length; i++) {
+            const jwk = keys[i];
+            if (typeof jwk.kty !== "string") {
+                throw new OperationError("Invalid JWK format");
+            } else if ("|RSA|EC|".indexOf(jwk.kty) === -1) {
+                throw new OperationError(`Unsupported JWK key type '${inputJson.kty}'`);
+            }
+
+            const key = r.KEYUTIL.getKey(jwk);
+            const pem = key.isPrivate ? r.KEYUTIL.getPEM(key, "PKCS8PRV") : r.KEYUTIL.getPEM(key);
+
+            // PEM ends with '\n', so a new key always starts on a new line
+            output += pem;
+        }
+
+        return output;
+    }
+}
+
+export default PEMToJWK;

src/core/operations/JWTSign.mjs

@@ -36,6 +36,11 @@ class JWTSign extends Operation {
                 name: "Signing algorithm",
                 type: "option",
                 value: JWT_ALGORITHMS
+            },
+            {
+                name: "Header",
+                type: "text",
+                value: "{}"
             }
         ];
     }
@@ -46,11 +51,12 @@ class JWTSign extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const [key, algorithm] = args;
+        const [key, algorithm, header] = args;
 
         try {
             return jwt.sign(input, key, {
-                algorithm: algorithm === "None" ? "none" : algorithm
+                algorithm: algorithm === "None" ? "none" : algorithm,
+                header: JSON.parse(header || "{}")
             });
         } catch (err) {
             throw new OperationError(`Error: Have you entered the key correctly? The key should be either the secret for HMAC algorithms or the PEM-encoded private key for RSA and ECDSA.

src/core/operations/JWTVerify.mjs

@@ -22,7 +22,7 @@ class JWTVerify extends Operation {
 
         this.name = "JWT Verify";
         this.module = "Crypto";
-        this.description = "Verifies that a JSON Web Token is valid and has been signed with the provided secret / private key.<br><br>The key should be either the secret for HMAC algorithms or the PEM-encoded private key for RSA and ECDSA.";
+        this.description = "Verifies that a JSON Web Token is valid and has been signed with the provided secret / private key.<br><br>The key should be either the secret for HMAC algorithms or the PEM-encoded public key for RSA and ECDSA.";
         this.infoURL = "https://wikipedia.org/wiki/JSON_Web_Token";
         this.inputType = "string";
         this.outputType = "JSON";

src/core/operations/Jq.mjs

@@ -0,0 +1,57 @@
+/**
+ * @author zhzy0077 [zhzy0077@hotmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import jq from "jq-web";
+
+/**
+ * jq operation
+ */
+class Jq extends Operation {
+
+    /**
+     * Jq constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Jq";
+        this.module = "Jq";
+        this.description = "jq is a lightweight and flexible command-line JSON processor.";
+        this.infoURL = "https://github.com/jqlang/jq";
+        this.inputType = "JSON";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Query",
+                type: "string",
+                value: ""
+            }
+        ];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [query] = args;
+        let result;
+
+        try {
+            result = jq.json(input, query);
+        } catch (err) {
+            throw new OperationError(`Invalid jq expression: ${err.message}`);
+        }
+
+        return JSON.stringify(result);
+    }
+
+}
+
+export default Jq;

src/core/operations/Jsonata.mjs

@@ -0,0 +1,65 @@
+/**
+ * @author Jon K (jon@ajarsoftware.com)
+ * @copyright Crown Copyright 2016
+ * @license Apache-2.0
+ */
+
+import jsonata from "jsonata";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Jsonata Query operation
+ */
+class JsonataQuery extends Operation {
+    /**
+     * JsonataQuery constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Jsonata Query";
+        this.module = "Code";
+        this.description =
+            "Query and transform JSON data with a jsonata query.";
+        this.infoURL = "https://docs.jsonata.org/overview.html";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Query",
+                type: "text",
+                value: "string",
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const [query] = args;
+        let result, jsonObj;
+
+        try {
+            jsonObj = JSON.parse(input);
+        } catch (err) {
+            throw new OperationError(`Invalid input JSON: ${err.message}`);
+        }
+
+        try {
+            const expression = jsonata(query);
+            result = await expression.evaluate(jsonObj);
+        } catch (err) {
+            throw new OperationError(
+                `Invalid Jsonata Expression: ${err.message}`
+            );
+        }
+
+        return JSON.stringify(result === undefined ? "" : result);
+    }
+}
+
+export default JsonataQuery;

src/core/operations/LZNT1Decompress.mjs

@@ -0,0 +1,41 @@
+/**
+ * @author 0xThiebaut [thiebaut.dev]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {decompress} from "../lib/LZNT1.mjs";
+
+/**
+ * LZNT1 Decompress operation
+ */
+class LZNT1Decompress extends Operation {
+
+    /**
+     * LZNT1 Decompress constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "LZNT1 Decompress";
+        this.module = "Compression";
+        this.description = "Decompresses data using the LZNT1 algorithm.<br><br>Similar to the Windows API <code>RtlDecompressBuffer</code>.";
+        this.infoURL = "https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-xca/5655f4a3-6ba4-489b-959f-e1f407c52f15";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    run(input, args) {
+        return decompress(input);
+    }
+
+}
+
+export default LZNT1Decompress;

src/core/operations/LevenshteinDistance.mjs

@@ -0,0 +1,98 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Levenshtein Distance operation
+ */
+class LevenshteinDistance extends Operation {
+
+    /**
+     * LevenshteinDistance constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Levenshtein Distance";
+        this.module = "Default";
+        this.description = "Levenshtein Distance (also known as Edit Distance) is a string metric to measure a difference between two strings that counts operations (insertions, deletions, and substitutions) on single character that are required to change one string to another.";
+        this.infoURL = "https://wikipedia.org/wiki/Levenshtein_distance";
+        this.inputType = "string";
+        this.outputType = "number";
+        this.args = [
+            {
+                name: "Sample delimiter",
+                type: "binaryString",
+                value: "\\n"
+            },
+            {
+                name: "Insertion cost",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Deletion cost",
+                type: "number",
+                value: 1
+            },
+            {
+                name: "Substitution cost",
+                type: "number",
+                value: 1
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {number}
+     */
+    run(input, args) {
+        const [delim, insCost, delCost, subCost] = args;
+        const samples = input.split(delim);
+        if (samples.length !== 2) {
+            throw new OperationError("Incorrect number of samples. Check your input and/or delimiter.");
+        }
+        if (insCost < 0 || delCost < 0 || subCost < 0) {
+            throw new OperationError("Negative costs are not allowed.");
+        }
+        const src = samples[0], dest = samples[1];
+        let currentCost = new Array(src.length + 1);
+        let nextCost = new Array(src.length + 1);
+        for (let i = 0; i < currentCost.length; i++) {
+            currentCost[i] = delCost * i;
+        }
+        for (let i = 0; i < dest.length; i++) {
+            const destc = dest.charAt(i);
+            nextCost[0] = currentCost[0] + insCost;
+            for (let j = 0; j < src.length; j++) {
+                let candidate;
+                // insertion
+                let optCost = currentCost[j + 1] + insCost;
+                // deletion
+                candidate = nextCost[j] + delCost;
+                if (candidate < optCost) optCost = candidate;
+                // substitution or matched character
+                candidate = currentCost[j];
+                if (src.charAt(j) !== destc) candidate += subCost;
+                if (candidate < optCost) optCost = candidate;
+                // store calculated cost
+                nextCost[j + 1] = optCost;
+            }
+            const tempCost = nextCost;
+            nextCost = currentCost;
+            currentCost = tempCost;
+        }
+
+        return currentCost[currentCost.length - 1];
+    }
+
+}
+
+export default LevenshteinDistance;

src/core/operations/LuhnChecksum.mjs

@@ -1,5 +1,6 @@
 /**
  * @author n1073645 [n1073645@gmail.com]
+ * @author k3ach [k3ach@proton.me]
  * @copyright Crown Copyright 2020
  * @license Apache-2.0
  */
@@ -20,39 +21,46 @@ class LuhnChecksum extends Operation {
 
         this.name = "Luhn Checksum";
         this.module = "Default";
-        this.description = "The Luhn algorithm, also known as the modulus 10 or mod 10 algorithm, is a simple checksum formula used to validate a variety of identification numbers, such as credit card numbers, IMEI numbers and Canadian Social Insurance Numbers.";
-        this.infoURL = "https://wikipedia.org/wiki/Luhn_algorithm";
+        this.description = "The Luhn mod N algorithm using the english alphabet. The Luhn mod N algorithm is an extension to the Luhn algorithm (also known as mod 10 algorithm) that allows it to work with sequences of values in any even-numbered base. This can be useful when a check digit is required to validate an identification string composed of letters, a combination of letters and digits or any arbitrary set of N characters where N is divisible by 2.";
+        this.infoURL = "https://en.wikipedia.org/wiki/Luhn_mod_N_algorithm";
         this.inputType = "string";
         this.outputType = "string";
-        this.args = [];
+        this.args = [
+            {
+                "name": "Radix",
+                "type": "number",
+                "value": 10
+            }
+        ];
     }
 
     /**
-     * Generates the Luhn Checksum from the input.
+     * Generates the Luhn checksum from the input.
      *
      * @param {string} inputStr
      * @returns {number}
      */
-    checksum(inputStr) {
+    checksum(inputStr, radix = 10) {
         let even = false;
         return inputStr.split("").reverse().reduce((acc, elem) => {
-            // Convert element to integer.
-            let temp = parseInt(elem, 10);
+            // Convert element to an integer based on the provided radix.
+            let temp = parseInt(elem, radix);
 
-            // If element is not an integer.
-            if (isNaN(temp))
-                throw new OperationError("Character: " + elem + " is not a digit.");
+            // If element is not a valid number in the given radix.
+            if (isNaN(temp)) {
+                throw new Error("Character: " + elem + " is not valid in radix " + radix + ".");
+            }
 
             // If element is in an even position
             if (even) {
-                // Double the element and add the quotient and remainder together.
-                temp = 2 * elem;
-                temp = Math.floor(temp/10) + (temp % 10);
+                // Double the element and sum the quotient and remainder.
+                temp = 2 * temp;
+                temp = Math.floor(temp / radix) + (temp % radix);
             }
 
             even = !even;
             return acc + temp;
-        }, 0)  % 10;
+        }, 0) % radix; // Use radix as the modulus base
     }
 
     /**
@@ -63,9 +71,20 @@ class LuhnChecksum extends Operation {
     run(input, args) {
         if (!input) return "";
 
-        const checkSum = this.checksum(input);
-        let checkDigit = this.checksum(input + "0");
-        checkDigit = checkDigit === 0 ? 0 : (10-checkDigit);
+        const radix = args[0];
+
+        if (radix < 2 || radix > 36) {
+            throw new OperationError("Error: Radix argument must be between 2 and 36");
+        }
+
+        if (radix % 2 !== 0) {
+            throw new OperationError("Error: Radix argument must be divisible by 2");
+        }
+
+        const checkSum = this.checksum(input, radix).toString(radix);
+        let checkDigit = this.checksum(input + "0", radix);
+        checkDigit = checkDigit === 0 ? 0 : (radix - checkDigit);
+        checkDigit = checkDigit.toString(radix);
 
         return `Checksum: ${checkSum}
 Checkdigit: ${checkDigit}

src/core/operations/MIMEDecoding.mjs

@@ -0,0 +1,171 @@
+/**
+ * @author mshwed [m@ttshwed.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import { fromHex } from "../lib/Hex.mjs";
+import { fromBase64 } from "../lib/Base64.mjs";
+import cptable from "codepage";
+
+/**
+ * MIME Decoding operation
+ */
+class MIMEDecoding extends Operation {
+
+    /**
+     * MIMEDecoding constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "MIME Decoding";
+        this.module = "Default";
+        this.description = "Enables the decoding of MIME message header extensions for non-ASCII text";
+        this.infoURL = "https://tools.ietf.org/html/rfc2047";
+        this.inputType = "byteArray";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const mimeEncodedText = Utils.byteArrayToUtf8(input);
+        const encodedHeaders = mimeEncodedText.replace(/\r\n/g, "\n");
+
+        const decodedHeader = this.decodeHeaders(encodedHeaders);
+
+        return decodedHeader;
+    }
+
+    /**
+     * Decode MIME header strings
+     *
+     * @param headerString
+     */
+    decodeHeaders(headerString) {
+        // No encoded words detected
+        let i = headerString.indexOf("=?");
+        if (i === -1) return headerString;
+
+        let decodedHeaders = headerString.slice(0, i);
+        let header = headerString.slice(i);
+
+        let isBetweenWords = false;
+        let start, cur, charset, encoding, j, end, text;
+        while (header.length > -1) {
+            start = header.indexOf("=?");
+            if (start === -1) break;
+            cur = start + "=?".length;
+
+            i = header.slice(cur).indexOf("?");
+            if (i === -1) break;
+
+            charset = header.slice(cur, cur + i);
+            cur += i + "?".length;
+
+            if (header.length < cur + "Q??=".length) break;
+
+            encoding = header[cur];
+            cur += 1;
+
+            if (header[cur] !== "?") break;
+
+            cur += 1;
+
+            j = header.slice(cur).indexOf("?=");
+            if (j === -1) break;
+
+            text = header.slice(cur, cur + j);
+            end = cur + j + "?=".length;
+
+            if (encoding.toLowerCase() === "b") {
+                text = fromBase64(text);
+            } else if (encoding.toLowerCase() === "q") {
+                text = this.parseQEncodedWord(text);
+            } else {
+                isBetweenWords = false;
+                decodedHeaders += header.slice(0, start + 2);
+                header = header.slice(start + 2);
+            }
+
+            if (start > 0 && (!isBetweenWords || header.slice(0, start).search(/\S/g) > -1)) {
+                decodedHeaders += header.slice(0, start);
+            }
+
+            decodedHeaders += this.convertFromCharset(charset, text);
+
+            header = header.slice(end);
+            isBetweenWords = true;
+        }
+
+        if (header.length > 0) {
+            decodedHeaders += header;
+        }
+
+        return decodedHeaders;
+    }
+
+    /**
+     * Converts decoded text for supported charsets.
+     * Supports UTF-8, US-ASCII, ISO-8859-*
+     *
+     * @param encodedWord
+     */
+    convertFromCharset(charset, encodedText) {
+        charset = charset.toLowerCase();
+        const parsedCharset = charset.split("-");
+
+        if (parsedCharset.length === 2 && parsedCharset[0] === "utf" && charset === "utf-8") {
+            return cptable.utils.decode(65001, encodedText);
+        } else if (parsedCharset.length === 2 && charset === "us-ascii") {
+            return cptable.utils.decode(20127, encodedText);
+        } else if (parsedCharset.length === 3 && parsedCharset[0] === "iso" && parsedCharset[1] === "8859") {
+            const isoCharset = parseInt(parsedCharset[2], 10);
+            if (isoCharset >= 1 && isoCharset <= 16) {
+                return cptable.utils.decode(28590 + isoCharset, encodedText);
+            }
+        }
+
+        throw new OperationError("Unhandled Charset");
+    }
+
+    /**
+     * Parses a Q encoded word
+     *
+     * @param encodedWord
+     */
+    parseQEncodedWord(encodedWord) {
+        let decodedWord = "";
+        for (let i = 0; i < encodedWord.length; i++) {
+            if (encodedWord[i] === "_") {
+                decodedWord += " ";
+            // Parse hex encoding
+            } else if (encodedWord[i] === "=") {
+                if ((i + 2) >= encodedWord.length) throw new OperationError("Incorrectly Encoded Word");
+                const decodedHex = Utils.byteArrayToChars(fromHex(encodedWord.substring(i + 1, i + 3)));
+                decodedWord += decodedHex;
+                i += 2;
+            } else if (
+                (encodedWord[i].charCodeAt(0) >= " ".charCodeAt(0) && encodedWord[i].charCodeAt(0) <= "~".charCodeAt(0)) ||
+                encodedWord[i] === "\n" ||
+                encodedWord[i] === "\r" ||
+                encodedWord[i] === "\t") {
+                decodedWord += encodedWord[i];
+            } else {
+                throw new OperationError("Incorrectly Encoded Word");
+            }
+        }
+
+        return decodedWord;
+    }
+}
+
+export default MIMEDecoding;

src/core/operations/Magic.mjs

@@ -149,7 +149,7 @@ class Magic extends Operation {
 
             output += `<tr>
                 <td><a href="#${recipeURL}">${Utils.generatePrettyRecipe(option.recipe, true)}</a></td>
-                <td>${Utils.escapeHtml(Utils.printable(Utils.truncate(option.data, 99)))}</td>
+                <td>${Utils.escapeHtml(Utils.escapeWhitespace(Utils.truncate(option.data, 99)))}</td>
                 <td>${language}${fileType}${matchingOps}${useful}${validUTF8}${entropy}</td>
             </tr>`;
         });

src/core/operations/MurmurHash3.mjs

@@ -0,0 +1,139 @@
+/**
+ * Based on murmurhash-js (https://github.com/garycourt/murmurhash-js)
+ * @author Gary Court
+ * @license MIT
+ *
+ * @author AliceGrey [alice@grey.systems]
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+
+/**
+ * MurmurHash3 operation
+ */
+class MurmurHash3 extends Operation {
+
+    /**
+     * MurmurHash3 constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "MurmurHash3";
+        this.module = "Hashing";
+        this.description = "Generates a MurmurHash v3 for a string input and an optional seed input";
+        this.infoURL = "https://wikipedia.org/wiki/MurmurHash";
+        this.inputType = "string";
+        this.outputType = "number";
+        this.args = [
+            {
+                name: "Seed",
+                type: "number",
+                value: 0
+            },
+            {
+                name: "Convert to Signed",
+                type: "boolean",
+                value: false
+            }
+        ];
+    }
+
+ /**
+ * Calculates the MurmurHash3 hash of the input.
+ * Based on Gary Court's JS MurmurHash implementation
+ * @see http://github.com/garycourt/murmurhash-js
+ * @author AliceGrey [alice@grey.systems]
+ * @param {string} input ASCII only
+ * @param {number} seed Positive integer only
+ * @return {number} 32-bit positive integer hash
+ */
+    mmh3(input, seed) {
+        let h1b;
+        let k1;
+        const remainder = input.length & 3; // input.length % 4
+        const bytes = input.length - remainder;
+        let h1 = seed;
+        const c1 = 0xcc9e2d51;
+        const c2 = 0x1b873593;
+        let i = 0;
+
+        while (i < bytes) {
+            k1 =
+                ((input.charCodeAt(i) & 0xff)) |
+                ((input.charCodeAt(++i) & 0xff) << 8) |
+                ((input.charCodeAt(++i) & 0xff) << 16) |
+                ((input.charCodeAt(++i) & 0xff) << 24);
+            ++i;
+
+            k1 = ((((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16))) & 0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = ((((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16))) & 0xffffffff;
+
+            h1 ^= k1;
+            h1 = (h1 << 13) | (h1 >>> 19);
+            h1b = ((((h1 & 0xffff) * 5) + ((((h1 >>> 16) * 5) & 0xffff) << 16))) & 0xffffffff;
+            h1 = (((h1b & 0xffff) + 0x6b64) + ((((h1b >>> 16) + 0xe654) & 0xffff) << 16));
+        }
+
+        k1 = 0;
+
+        if (remainder === 3) {
+            k1 ^= (input.charCodeAt(i + 2) & 0xff) << 16;
+        }
+
+        if (remainder === 3 || remainder === 2) {
+            k1 ^= (input.charCodeAt(i + 1) & 0xff) << 8;
+        }
+
+        if (remainder === 3 || remainder === 2 || remainder === 1) {
+            k1 ^= (input.charCodeAt(i) & 0xff);
+
+            k1 = (((k1 & 0xffff) * c1) + ((((k1 >>> 16) * c1) & 0xffff) << 16)) & 0xffffffff;
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = (((k1 & 0xffff) * c2) + ((((k1 >>> 16) * c2) & 0xffff) << 16)) & 0xffffffff;
+            h1 ^= k1;
+        }
+
+        h1 ^= input.length;
+
+        h1 ^= h1 >>> 16;
+        h1 = (((h1 & 0xffff) * 0x85ebca6b) + ((((h1 >>> 16) * 0x85ebca6b) & 0xffff) << 16)) & 0xffffffff;
+        h1 ^= h1 >>> 13;
+        h1 = ((((h1 & 0xffff) * 0xc2b2ae35) + ((((h1 >>> 16) * 0xc2b2ae35) & 0xffff) << 16))) & 0xffffffff;
+        h1 ^= h1 >>> 16;
+
+        return h1 >>> 0;
+    }
+
+    /**
+    * Converts an unsigned 32-bit integer to a signed 32-bit integer
+    * @author AliceGrey [alice@grey.systems]
+    * @param {value} 32-bit unsigned integer
+    * @return {number} 32-bit signed integer
+    */
+    unsignedToSigned(value) {
+        return value & 0x80000000 ? -0x100000000 + value : value;
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {number}
+     */
+    run(input, args) {
+        if (args && args.length >= 1) {
+            const seed = args[0];
+            const hash = this.mmh3(input, seed);
+            if (args.length > 1 && args[1]) {
+                return this.unsignedToSigned(hash);
+            }
+            return hash;
+        }
+        return this.mmh3(input);
+    }
+}
+
+export default MurmurHash3;

src/core/operations/NTHash.mjs

@@ -5,8 +5,6 @@
  */
 
 import Operation from "../Operation.mjs";
-
-import cptable from "codepage";
 import {runHash} from "../lib/Hash.mjs";
 
 /**
@@ -35,10 +33,14 @@ class NTHash extends Operation {
      * @returns {string}
      */
     run(input, args) {
-        const format = 1200; // UTF-16LE
-        const encoded = cptable.utils.encode(format, input);
-        const hashed = runHash("md4", encoded);
+        // Convert to UTF-16LE
+        const buf = new ArrayBuffer(input.length * 2);
+        const bufView = new Uint16Array(buf);
+        for (let i = 0; i < input.length; i++) {
+            bufView[i] = input.charCodeAt(i);
+        }
 
+        const hashed = runHash("md4", buf);
         return hashed.toUpperCase();
     }
 }

src/core/operations/NormaliseImage.mjs

@@ -8,8 +8,7 @@ import Operation from "../Operation.mjs";
 import OperationError from "../errors/OperationError.mjs";
 import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
-import jimplib from "jimp/es/index.js";
-const jimp = jimplib.default ? jimplib.default : jimplib;
+import Jimp from "jimp/es/index.js";
 
 /**
  * Normalise Image operation
@@ -44,7 +43,7 @@ class NormaliseImage extends Operation {
 
         let image;
         try {
-            image = await jimp.read(input);
+            image = await Jimp.read(input);
         } catch (err) {
             throw new OperationError(`Error opening image file. (${err})`);
         }
@@ -54,9 +53,9 @@ class NormaliseImage extends Operation {
 
             let imageBuffer;
             if (image.getMIME() === "image/gif") {
-                imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+                imageBuffer = await image.getBufferAsync(Jimp.MIME_PNG);
             } else {
-                imageBuffer = await image.getBufferAsync(jimp.AUTO);
+                imageBuffer = await image.getBufferAsync(Jimp.AUTO);
             }
             return imageBuffer.buffer;
         } catch (err) {

src/core/operations/OpticalCharacterRecognition.mjs

@@ -12,9 +12,10 @@ import { isImage } from "../lib/FileType.mjs";
 import { toBase64 } from "../lib/Base64.mjs";
 import { isWorkerEnvironment } from "../Utils.mjs";
 
-import process from "process";
 import { createWorker } from "tesseract.js";
 
+const OEM_MODES = ["Tesseract only", "LSTM only", "Tesseract/LSTM Combined"];
+
 /**
  * Optical Character Recognition operation
  */
@@ -37,6 +38,12 @@ class OpticalCharacterRecognition extends Operation {
                 name: "Show confidence",
                 type: "boolean",
                 value: true
+            },
+            {
+                name: "OCR Engine Mode",
+                type: "option",
+                value: OEM_MODES,
+                defaultIndex: 1
             }
         ];
     }
@@ -47,7 +54,7 @@ class OpticalCharacterRecognition extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [showConfidence] = args;
+        const [showConfidence, oemChoice] = args;
 
         if (!isWorkerEnvironment()) throw new OperationError("This operation only works in a browser");
 
@@ -56,12 +63,13 @@ class OpticalCharacterRecognition extends Operation {
             throw new OperationError("Unsupported file type (supported: jpg,png,pbm,bmp) or no file provided");
         }
 
-        const assetDir = isWorkerEnvironment() ? `${self.docURL}/assets/` : `${process.cwd()}/src/core/vendor/`;
+        const assetDir = `${self.docURL}/assets/`;
+        const oem = OEM_MODES.indexOf(oemChoice);
 
         try {
             self.sendStatusMessage("Spinning up Tesseract worker...");
             const image = `data:${type};base64,${toBase64(input)}`;
-            const worker = createWorker({
+            const worker = await createWorker("eng", oem, {
                 workerPath: `${assetDir}tesseract/worker.min.js`,
                 langPath: `${assetDir}tesseract/lang-data`,
                 corePath: `${assetDir}tesseract/tesseract-core.wasm.js`,
@@ -71,11 +79,6 @@ class OpticalCharacterRecognition extends Operation {
                     }
                 }
             });
-            await worker.load();
-            self.sendStatusMessage(`Loading English language pack...`);
-            await worker.loadLanguage("eng");
-            self.sendStatusMessage("Intialising Tesseract API...");
-            await worker.initialize("eng");
             self.sendStatusMessage("Finding text...");
             const result = await worker.recognize(image);
 

src/core/operations/PEMToJWK.mjs

@@ -0,0 +1,88 @@
+/**
+ * @author cplussharp
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import r from "jsrsasign";
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * PEM to JWK operation
+ */
+class PEMToJWK extends Operation {
+
+    /**
+     * PEMToJWK constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "PEM to JWK";
+        this.module = "PublicKey";
+        this.description = "Converts Keys in PEM format to a JSON Web Key format.";
+        this.infoURL = "https://datatracker.ietf.org/doc/html/rfc7517";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [];
+        this.checks = [
+            {
+                "pattern": "-----BEGIN ((RSA |EC )?(PRIVATE|PUBLIC) KEY|CERTIFICATE)-----",
+                "args": []
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        let output = "";
+        let match;
+        const regex = /-----BEGIN ([A-Z][A-Z ]+[A-Z])-----/g;
+        while ((match = regex.exec(input)) !== null) {
+            // find corresponding end tag
+            const indexBase64 = match.index + match[0].length;
+            const header = input.substring(match.index, indexBase64);
+            const footer = `-----END ${match[1]}-----`;
+            const indexFooter = input.indexOf(footer, indexBase64);
+            if (indexFooter === -1) {
+                throw new OperationError(`PEM footer '${footer}' not found`);
+            }
+
+            const pem = input.substring(match.index, indexFooter + footer.length);
+            if (match[1].indexOf("KEY") !== -1) {
+                if (header === "-----BEGIN RSA PUBLIC KEY-----") {
+                    throw new OperationError("Unsupported RSA public key format. Only PKCS#8 is supported.");
+                }
+
+                const key = r.KEYUTIL.getKey(pem);
+                if (key.type === "DSA") {
+                    throw new OperationError("DSA keys are not supported for JWK");
+                }
+                const jwk = r.KEYUTIL.getJWKFromKey(key);
+                if (output.length > 0) {
+                    output += "\n";
+                }
+                output += JSON.stringify(jwk);
+            } else if (match[1] === "CERTIFICATE") {
+                const cert = new r.X509();
+                cert.readCertPEM(pem);
+                const key = cert.getPublicKey();
+                const jwk = r.KEYUTIL.getJWKFromKey(key);
+                if (output.length > 0) {
+                    output += "\n";
+                }
+                output += JSON.stringify(jwk);
+            } else {
+                throw new OperationError(`Unsupported PEM type '${match[1]}'`);
+            }
+        }
+        return output;
+    }
+}
+
+export default PEMToJWK;

src/core/operations/PHPSerialize.mjs

@@ -0,0 +1,126 @@
+/**
+ * @author brun0ne [brunonblok@gmail.com]
+ * @copyright Crown Copyright 2023
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * PHP Serialize operation
+ */
+class PHPSerialize extends Operation {
+
+    /**
+     * PHPSerialize constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "PHP Serialize";
+        this.module = "Default";
+        this.description = "Performs PHP serialization on JSON data.<br><br>This function does not support <code>object</code> tags.<br><br>Since PHP doesn't distinguish dicts and arrays, this operation is not always symmetric to <code>PHP Deserialize</code>.<br><br>Example:<br><code>[5,&quot;abc&quot;,true]</code><br>becomes<br><code>a:3:{i:0;i:5;i:1;s:3:&quot;abc&quot;;i:2;b:1;}<code>";
+        this.infoURL = "https://www.phpinternalsbook.com/php5/classes_objects/serialization.html";
+        this.inputType = "JSON";
+        this.outputType = "string";
+        this.args = [];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        /**
+         * Determines if a number is an integer
+         * @param {number} value
+         * @returns {boolean}
+         */
+        function isInteger(value) {
+            return typeof value === "number" && parseInt(value.toString(), 10) === value;
+        }
+
+        /**
+         * Serialize basic types
+         * @param {string | number | boolean} content
+         * @returns {string}
+         */
+        function serializeBasicTypes(content) {
+            const basicTypes = {
+                "string": "s",
+                "integer": "i",
+                "float": "d",
+                "boolean": "b"
+            };
+            /**
+             * Booleans
+             * cast to 0 or 1
+             */
+            if (typeof content === "boolean") {
+                return `${basicTypes.boolean}:${content ? 1 : 0}`;
+            }
+            /* Numbers */
+            if (typeof content === "number") {
+                if (isInteger(content)) {
+                    return `${basicTypes.integer}:${content.toString()}`;
+                } else {
+                    return `${basicTypes.float}:${content.toString()}`;
+                }
+            }
+            /* Strings */
+            if (typeof content === "string")
+                return `${basicTypes.string}:${content.length}:"${content}"`;
+
+            /** This should be unreachable */
+            throw new OperationError(`Encountered a non-implemented type: ${typeof content}`);
+        }
+
+        /**
+         * Recursively serialize
+         * @param {*} object
+         * @returns {string}
+         */
+        function serialize(object) {
+            /* Null */
+            if (object == null) {
+                return `N;`;
+            }
+
+            if (typeof object !== "object") {
+                /* Basic types */
+                return `${serializeBasicTypes(object)};`;
+            } else if (object instanceof Array) {
+                /* Arrays */
+                const serializedElements = [];
+
+                for (let i = 0; i < object.length; i++) {
+                    serializedElements.push(`${serialize(i)}${serialize(object[i])}`);
+                }
+
+                return `a:${object.length}:{${serializedElements.join("")}}`;
+            } else if (object instanceof Object) {
+                /**
+                 * Objects
+                 * Note: the output cannot be guaranteed to be in the same order as the input
+                 */
+                const serializedElements = [];
+                const keys = Object.keys(object);
+
+                for (const key of keys) {
+                    serializedElements.push(`${serialize(key)}${serialize(object[key])}`);
+                }
+
+                return `a:${keys.length}:{${serializedElements.join("")}}`;
+            }
+
+            /** This should be unreachable */
+            throw new OperationError(`Encountered a non-implemented type: ${typeof object}`);
+        }
+
+        return serialize(input);
+    }
+}
+
+export default PHPSerialize;

src/core/operations/PLISTViewer.mjs

@@ -48,7 +48,7 @@ class PlistViewer extends Operation {
             .replace(/<true\/>/g, m => "true")
             .replace(/<\/plist>/g, "/plist")
             .replace(/<date>.+<\/date>/g, m => `${m.slice(6, m.indexOf(/<\/integer>/g)-6)}`)
-            .replace(/<data>(\s|.)+?<\/data>/g, m => `${m.slice(6, m.indexOf(/<\/data>/g)-6)}`)
+            .replace(/<data>[\s\S]+?<\/data>/g, m => `${m.slice(6, m.indexOf(/<\/data>/g)-6)}`)
             .replace(/[ \t\r\f\v]/g, "");
 
         /**