Merge branch 'feature/bombe' into feature/typex

src/core/operations/BlurImage.mjs

@@ -0,0 +1,102 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Blur Image operation
+ */
+class BlurImage extends Operation {
+
+    /**
+     * BlurImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Blur Image";
+        this.module = "Image";
+        this.description = "Applies a blur effect to the image.<br><br>Gaussian blur is much slower than fast blur, but produces better results.";
+        this.infoURL = "https://wikipedia.org/wiki/Gaussian_blur";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Amount",
+                type: "number",
+                value: 5,
+                min: 1
+            },
+            {
+                name: "Type",
+                type: "option",
+                value: ["Fast", "Gaussian"]
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [blurAmount, blurType] = args;
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            switch (blurType){
+                case "Fast":
+                    image.blur(blurAmount);
+                    break;
+                case "Gaussian":
+                    if (ENVIRONMENT_IS_WORKER())
+                        self.sendStatusMessage("Gaussian blurring image. This may take a while...");
+                    image.gaussian(blurAmount);
+                    break;
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error blurring image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the blurred image using HTML for web apps
+     *
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default BlurImage;

src/core/operations/Bombe.mjs

@@ -23,7 +23,7 @@ class Bombe extends Operation {
 
         this.name = "Bombe";
         this.module = "Default";
-        this.description = "Emulation of the Bombe machine used to attack Enigma.<br><br>To run this you need to have a 'crib', which is some known plaintext for a chunk of the target ciphertext, and know the rotors used. (See the 'Bombe (multiple runs)' operation if you don't know the rotors.) The machine will suggest possible configurations of the Enigma. Each suggestion has the rotor start positions (left to right) and known plugboard pairs.<br><br>Choosing a crib: First, note that Enigma cannot encrypt a letter to itself, which allows you to rule out some positions for possible cribs. Secondly, the Bombe does not simulate the Enigma's middle rotor stepping. The longer your crib, the more likely a step happened within it, which will prevent the attack working. However, other than that, longer cribs are generally better. The attack produces a 'menu' which maps ciphertext letters to plaintext, and the goal is to produce 'loops': for example, with ciphertext ABC and crib CAB, we have the mappings A&lt;-&gt;C, B&lt;-&gt;A, and C&lt;-&gt;B, which produces a loop A-B-C-A. The more loops, the better the crib. The operation will output this: if your menu has too few loops, a large number of incorrect outputs will be produced. Try a different crib. If the menu seems good but the right answer isn't produced, your crib may be wrong, or you may have overlapped the middle rotor stepping - try a different crib.<br><br>Output is not sufficient to fully decrypt the data. You will have to recover the rest of the plugboard settings by inspection. And the ring position is not taken into account: this affects when the middle rotor steps. If your output is correct for a bit, and then goes wrong, adjust the ring and start position on the right-hand rotor together until the output improves. If necessary, repeat for the middle rotor.<br><br>By default this operation runs the checking machine, a manual process to verify the quality of Bombe stops, on each stop, discarding stops which fail. If you want to see how many times the hardware actually stops for a given input, disable the checking machine.";
+        this.description = "Emulation of the Bombe machine used at Bletchley Park to attack Enigma, based on work by Polish and British cryptanalysts.<br><br>To run this you need to have a 'crib', which is some known plaintext for a chunk of the target ciphertext, and know the rotors used. (See the 'Bombe (multiple runs)' operation if you don't know the rotors.) The machine will suggest possible configurations of the Enigma. Each suggestion has the rotor start positions (left to right) and known plugboard pairs.<br><br>Choosing a crib: First, note that Enigma cannot encrypt a letter to itself, which allows you to rule out some positions for possible cribs. Secondly, the Bombe does not simulate the Enigma's middle rotor stepping. The longer your crib, the more likely a step happened within it, which will prevent the attack working. However, other than that, longer cribs are generally better. The attack produces a 'menu' which maps ciphertext letters to plaintext, and the goal is to produce 'loops': for example, with ciphertext ABC and crib CAB, we have the mappings A&lt;-&gt;C, B&lt;-&gt;A, and C&lt;-&gt;B, which produces a loop A-B-C-A. The more loops, the better the crib. The operation will output this: if your menu has too few loops or is too short, a large number of incorrect outputs will usually be produced. Try a different crib. If the menu seems good but the right answer isn't produced, your crib may be wrong, or you may have overlapped the middle rotor stepping - try a different crib.<br><br>Output is not sufficient to fully decrypt the data. You will have to recover the rest of the plugboard settings by inspection. And the ring position is not taken into account: this affects when the middle rotor steps. If your output is correct for a bit, and then goes wrong, adjust the ring and start position on the right-hand rotor together until the output improves. If necessary, repeat for the middle rotor.<br><br>By default this operation runs the checking machine, a manual process to verify the quality of Bombe stops, on each stop, discarding stops which fail. If you want to see how many times the hardware actually stops for a given input, disable the checking machine.";
         this.infoURL = "https://wikipedia.org/wiki/Bombe";
         this.inputType = "string";
         this.outputType = "JSON";

src/core/operations/ContainImage.mjs

@@ -0,0 +1,143 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Contain Image operation
+ */
+class ContainImage extends Operation {
+
+    /**
+     * ContainImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Contain Image";
+        this.module = "Image";
+        this.description = "Scales an image to the specified width and height, maintaining the aspect ratio. The image may be letterboxed.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Width",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Height",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Horizontal align",
+                type: "option",
+                value: [
+                    "Left",
+                    "Center",
+                    "Right"
+                ],
+                defaultIndex: 1
+            },
+            {
+                name: "Vertical align",
+                type: "option",
+                value: [
+                    "Top",
+                    "Middle",
+                    "Bottom"
+                ],
+                defaultIndex: 1
+            },
+            {
+                name: "Resizing algorithm",
+                type: "option",
+                value: [
+                    "Nearest Neighbour",
+                    "Bilinear",
+                    "Bicubic",
+                    "Hermite",
+                    "Bezier"
+                ],
+                defaultIndex: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [width, height, hAlign, vAlign, alg] = args;
+
+        const resizeMap = {
+            "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
+            "Bilinear": jimp.RESIZE_BILINEAR,
+            "Bicubic": jimp.RESIZE_BICUBIC,
+            "Hermite": jimp.RESIZE_HERMITE,
+            "Bezier": jimp.RESIZE_BEZIER
+        };
+
+        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
+        };
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Containing image...");
+            image.contain(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error containing image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the contained image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default ContainImage;

src/core/operations/CoverImage.mjs

@@ -0,0 +1,143 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Cover Image operation
+ */
+class CoverImage extends Operation {
+
+    /**
+     * CoverImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Cover Image";
+        this.module = "Image";
+        this.description = "Scales the image to the given width and height, keeping the aspect ratio. The image may be clipped.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Width",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Height",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Horizontal align",
+                type: "option",
+                value: [
+                    "Left",
+                    "Center",
+                    "Right"
+                ],
+                defaultIndex: 1
+            },
+            {
+                name: "Vertical align",
+                type: "option",
+                value: [
+                    "Top",
+                    "Middle",
+                    "Bottom"
+                ],
+                defaultIndex: 1
+            },
+            {
+                name: "Resizing algorithm",
+                type: "option",
+                value: [
+                    "Nearest Neighbour",
+                    "Bilinear",
+                    "Bicubic",
+                    "Hermite",
+                    "Bezier"
+                ],
+                defaultIndex: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [width, height, hAlign, vAlign, alg] = args;
+
+        const resizeMap = {
+            "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
+            "Bilinear": jimp.RESIZE_BILINEAR,
+            "Bicubic": jimp.RESIZE_BICUBIC,
+            "Hermite": jimp.RESIZE_HERMITE,
+            "Bezier": jimp.RESIZE_BEZIER
+        };
+
+        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
+        };
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Covering image...");
+            image.cover(width, height, alignMap[hAlign] | alignMap[vAlign], resizeMap[alg]);
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error covering image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the covered image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default CoverImage;

src/core/operations/CropImage.mjs

@@ -0,0 +1,144 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Crop Image operation
+ */
+class CropImage extends Operation {
+
+    /**
+     * CropImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Crop Image";
+        this.module = "Image";
+        this.description = "Crops an image to the specified region, or automatically crops edges.<br><br><b><u>Autocrop</u></b><br>Automatically crops same-colour borders from the image.<br><br><u>Autocrop tolerance</u><br>A percentage value for the tolerance of colour difference between pixels.<br><br><u>Only autocrop frames</u><br>Only crop real frames (all sides must have the same border)<br><br><u>Symmetric autocrop</u><br>Force autocrop to be symmetric (top/bottom and left/right are cropped by the same amount)<br><br><u>Autocrop keep border</u><br>The number of pixels of border to leave around the image.";
+        this.infoURL = "https://wikipedia.org/wiki/Cropping_(image)";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "X Position",
+                type: "number",
+                value: 0,
+                min: 0
+            },
+            {
+                name: "Y Position",
+                type: "number",
+                value: 0,
+                min: 0
+            },
+            {
+                name: "Width",
+                type: "number",
+                value: 10,
+                min: 1
+            },
+            {
+                name: "Height",
+                type: "number",
+                value: 10,
+                min: 1
+            },
+            {
+                name: "Autocrop",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Autocrop tolerance (%)",
+                type: "number",
+                value: 0.02,
+                min: 0,
+                max: 100,
+                step: 0.01
+            },
+            {
+                name: "Only autocrop frames",
+                type: "boolean",
+                value: true
+            },
+            {
+                name: "Symmetric autocrop",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Autocrop keep border (px)",
+                type: "number",
+                value: 0,
+                min: 0
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [xPos, yPos, width, height, autocrop, autoTolerance, autoFrames, autoSymmetric, autoBorder] = args;
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Cropping image...");
+            if (autocrop) {
+                image.autocrop({
+                    tolerance: (autoTolerance / 100),
+                    cropOnlyFrames: autoFrames,
+                    cropSymmetric: autoSymmetric,
+                    leaveBorder: autoBorder
+                });
+            } else {
+                image.crop(xPos, yPos, width, height);
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error cropping image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the cropped image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default CropImage;

src/core/operations/DetectFileType.mjs

@@ -5,7 +5,8 @@
  */
 
 import Operation from "../Operation";
-import Magic from "../lib/Magic";
+import {detectFileType} from "../lib/FileType";
+import {FILE_SIGNATURES} from "../lib/FileSignatures";
 
 /**
  * Detect File Type operation
@@ -24,7 +25,13 @@ class DetectFileType extends Operation {
         this.infoURL = "https://wikipedia.org/wiki/List_of_file_signatures";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
-        this.args = [];
+        this.args = Object.keys(FILE_SIGNATURES).map(cat => {
+            return {
+                name: cat,
+                type: "boolean",
+                value: true
+            };
+        });
     }
 
     /**
@@ -34,17 +41,27 @@ class DetectFileType extends Operation {
      */
     run(input, args) {
         const data = new Uint8Array(input),
-            type = Magic.magicFileType(data);
+            categories = [];
 
-        if (!type) {
+        args.forEach((cat, i) => {
+            if (cat) categories.push(Object.keys(FILE_SIGNATURES)[i]);
+        });
+
+        const types = detectFileType(data, categories);
+
+        if (!types.length) {
             return "Unknown file type. Have you tried checking the entropy of this data to determine whether it might be encrypted or compressed?";
         } else {
-            let output = "File extension: " + type.ext + "\n" +
-                "MIME type:      " + type.mime;
+            let output = "";
 
-            if (type.desc && type.desc.length) {
-                output += "\nDescription:    " + type.desc;
-            }
+            types.forEach(type => {
+                output += "File extension: " + type.extension + "\n" +
+                    "MIME type:      " + type.mime + "\n";
+
+                if (type.description && type.description.length) {
+                    output += "\nDescription:    " + type.description + "\n";
+                }
+            });
 
             return output;
         }

src/core/operations/DitherImage.mjs

@@ -0,0 +1,79 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Image Dither operation
+ */
+class DitherImage extends Operation {
+
+    /**
+     * DitherImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Dither Image";
+        this.module = "Image";
+        this.description = "Apply a dither effect to an image.";
+        this.infoURL = "https://wikipedia.org/wiki/Dither";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Applying dither to image...");
+            image.dither565();
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error applying dither to image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the dithered image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default DitherImage;

src/core/operations/Enigma.mjs

@@ -22,7 +22,7 @@ class Enigma extends Operation {
 
         this.name = "Enigma";
         this.module = "Default";
-        this.description = "Encipher/decipher with the WW2 Enigma machine.<br><br>The standard set of German military rotors and reflectors are provided. To configure the plugboard, enter a string of connected pairs of letters, e.g. <code>AB CD EF</code> connects A to B, C to D, and E to F. This is also used to create your own reflectors. To create your own rotor, enter the letters that the rotor maps A to Z to, in order, optionally followed by <code>&lt;</code> then a list of stepping points.<br>This is deliberately fairly permissive with rotor placements etc compared to a real Enigma (on which, for example, a four-rotor Enigma uses the thin reflectors and the beta or gamma rotor in the 4th slot).";
+        this.description = "Encipher/decipher with the WW2 Enigma machine.<br><br>Enigma was used by the German military, among others, around the WW2 era as a portable cipher machine to protect sensitive military, diplomatic and commercial communications.<br><br>The standard set of German military rotors and reflectors are provided. To configure the plugboard, enter a string of connected pairs of letters, e.g. <code>AB CD EF</code> connects A to B, C to D, and E to F. This is also used to create your own reflectors. To create your own rotor, enter the letters that the rotor maps A to Z to, in order, optionally followed by <code>&lt;</code> then a list of stepping points.<br>This is deliberately fairly permissive with rotor placements etc compared to a real Enigma (on which, for example, a four-rotor Enigma uses only the thin reflectors and the beta or gamma rotor in the 4th slot).";
         this.infoURL = "https://wikipedia.org/wiki/Enigma_machine";
         this.inputType = "string";
         this.outputType = "string";

src/core/operations/ExtractFiles.mjs

@@ -0,0 +1,100 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import Utils from "../Utils";
+import {scanForFileTypes, extractFile} from "../lib/FileType";
+import {FILE_SIGNATURES} from "../lib/FileSignatures";
+
+/**
+ * Extract Files operation
+ */
+class ExtractFiles extends Operation {
+
+    /**
+     * ExtractFiles constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Extract Files";
+        this.module = "Default";
+        this.description = "TODO";
+        this.infoURL = "https://forensicswiki.org/wiki/File_Carving";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "List<File>";
+        this.presentType = "html";
+        this.args = Object.keys(FILE_SIGNATURES).map(cat => {
+            return {
+                name: cat,
+                type: "boolean",
+                value: cat === "Miscellaneous" ? false : true
+            };
+        }).concat([
+            {
+                name: "Ignore failed extractions",
+                type: "boolean",
+                value: "true"
+            }
+        ]);
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {List<File>}
+     */
+    run(input, args) {
+        const bytes = new Uint8Array(input),
+            categories = [],
+            ignoreFailedExtractions = args.pop(1);
+
+        args.forEach((cat, i) => {
+            if (cat) categories.push(Object.keys(FILE_SIGNATURES)[i]);
+        });
+
+        // Scan for embedded files
+        const detectedFiles = scanForFileTypes(bytes, categories);
+
+        // Extract each file that we support
+        const files = [];
+        const errors = [];
+        detectedFiles.forEach(detectedFile => {
+            try {
+                files.push(extractFile(bytes, detectedFile.fileDetails, detectedFile.offset));
+            } catch (err) {
+                if (!ignoreFailedExtractions && err.message.indexOf("No extraction algorithm available") < 0) {
+                    errors.push(
+                        `Error while attempting to extract ${detectedFile.fileDetails.name} ` +
+                        `at offset ${detectedFile.offset}:\n` +
+                        `${err.message}`
+                    );
+                }
+            }
+        });
+
+        if (errors.length) {
+            throw new OperationError(errors.join("\n\n"));
+        }
+
+        return files;
+    }
+
+
+    /**
+     * Displays the files in HTML for web apps.
+     *
+     * @param {File[]} files
+     * @returns {html}
+     */
+    async present(files) {
+        return await Utils.displayFilesAsHTML(files);
+    }
+
+}
+
+export default ExtractFiles;

src/core/operations/FlipImage.mjs

@@ -0,0 +1,94 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Flip Image operation
+ */
+class FlipImage extends Operation {
+
+    /**
+     * FlipImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Flip Image";
+        this.module = "Image";
+        this.description = "Flips an image along its X or Y axis.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Axis",
+                type: "option",
+                value: ["Horizontal", "Vertical"]
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [flipAxis] = args;
+        if (!isImage(input)) {
+            throw new OperationError("Invalid input file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Flipping image...");
+            switch (flipAxis){
+                case "Horizontal":
+                    image.flip(true, false);
+                    break;
+                case "Vertical":
+                    image.flip(false, true);
+                    break;
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error flipping image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the flipped image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default FlipImage;

src/core/operations/Fork.mjs

@@ -89,7 +89,7 @@ class Fork extends Operation {
         // Run recipe over each tranche
         for (i = 0; i < inputs.length; i++) {
             // Baseline ing values for each tranche so that registers are reset
-            subOpList.forEach((op, i) => {
+            recipe.opList.forEach((op, i) => {
                 op.ingValues = JSON.parse(JSON.stringify(ingValues[i]));
             });
 

src/core/operations/GenerateQRCode.mjs

@@ -8,7 +8,7 @@ import Operation from "../Operation";
 import OperationError from "../errors/OperationError";
 import qr from "qr-image";
 import { toBase64 } from "../lib/Base64";
-import Magic from "../lib/Magic";
+import { isImage } from "../lib/FileType";
 import Utils from "../Utils";
 
 /**
@@ -100,9 +100,9 @@ class GenerateQRCode extends Operation {
 
         if (format === "PNG") {
             let dataURI = "data:";
-            const type = Magic.magicFileType(data);
-            if (type && type.mime.indexOf("image") === 0){
-                dataURI += type.mime + ";";
+            const mime = isImage(data);
+            if (mime){
+                dataURI += mime + ";";
             } else {
                 throw new OperationError("Invalid PNG file generated by QR image");
             }

src/core/operations/ImageBrightnessContrast.mjs

@@ -0,0 +1,103 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Image Brightness / Contrast operation
+ */
+class ImageBrightnessContrast extends Operation {
+
+    /**
+     * ImageBrightnessContrast constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Image Brightness / Contrast";
+        this.module = "Image";
+        this.description = "Adjust the brightness or contrast of an image.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Brightness",
+                type: "number",
+                value: 0,
+                min: -100,
+                max: 100
+            },
+            {
+                name: "Contrast",
+                type: "number",
+                value: 0,
+                min: -100,
+                max: 100
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [brightness, contrast] = args;
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (brightness !== 0) {
+                if (ENVIRONMENT_IS_WORKER())
+                    self.sendStatusMessage("Changing image brightness...");
+                image.brightness(brightness / 100);
+            }
+            if (contrast !== 0) {
+                if (ENVIRONMENT_IS_WORKER())
+                    self.sendStatusMessage("Changing image contrast...");
+                image.contrast(contrast / 100);
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error adjusting image brightness or contrast. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default ImageBrightnessContrast;

src/core/operations/ImageFilter.mjs

@@ -0,0 +1,94 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Image Filter operation
+ */
+class ImageFilter extends Operation {
+
+    /**
+     * ImageFilter constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Image Filter";
+        this.module = "Image";
+        this.description = "Applies a greyscale or sepia filter to an image.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Filter type",
+                type: "option",
+                value: [
+                    "Greyscale",
+                    "Sepia"
+                ]
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [filterType] = args;
+        if (!isImage(input)){
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Applying " + filterType.toLowerCase() + " filter to image...");
+            if (filterType === "Greyscale") {
+                image.greyscale();
+            } else {
+                image.sepia();
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error applying filter to image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the blurred image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default ImageFilter;

src/core/operations/ImageHueSaturationLightness.mjs

@@ -0,0 +1,129 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Image Hue/Saturation/Lightness operation
+ */
+class ImageHueSaturationLightness extends Operation {
+
+    /**
+     * ImageHueSaturationLightness constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Image Hue/Saturation/Lightness";
+        this.module = "Image";
+        this.description = "Adjusts the hue / saturation / lightness (HSL) values of an image.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Hue",
+                type: "number",
+                value: 0,
+                min: -360,
+                max: 360
+            },
+            {
+                name: "Saturation",
+                type: "number",
+                value: 0,
+                min: -100,
+                max: 100
+            },
+            {
+                name: "Lightness",
+                type: "number",
+                value: 0,
+                min: -100,
+                max: 100
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [hue, saturation, lightness] = args;
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (hue !== 0) {
+                if (ENVIRONMENT_IS_WORKER())
+                    self.sendStatusMessage("Changing image hue...");
+                image.colour([
+                    {
+                        apply: "hue",
+                        params: [hue]
+                    }
+                ]);
+            }
+            if (saturation !== 0) {
+                if (ENVIRONMENT_IS_WORKER())
+                    self.sendStatusMessage("Changing image saturation...");
+                image.colour([
+                    {
+                        apply: "saturate",
+                        params: [saturation]
+                    }
+                ]);
+            }
+            if (lightness !== 0) {
+                if (ENVIRONMENT_IS_WORKER())
+                    self.sendStatusMessage("Changing image lightness...");
+                image.colour([
+                    {
+                        apply: "lighten",
+                        params: [lightness]
+                    }
+                ]);
+            }
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error adjusting image hue / saturation / lightness. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+}
+
+export default ImageHueSaturationLightness;

src/core/operations/ImageOpacity.mjs

@@ -0,0 +1,89 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Image Opacity operation
+ */
+class ImageOpacity extends Operation {
+
+    /**
+     * ImageOpacity constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Image Opacity";
+        this.module = "Image";
+        this.description = "Adjust the opacity of an image.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Opacity (%)",
+                type: "number",
+                value: 100,
+                min: 0,
+                max: 100
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [opacity] = args;
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Changing image opacity...");
+            image.opacity(opacity / 100);
+
+            const imageBuffer = await image.getBufferAsync(jimp.MIME_PNG);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error changing image opacity. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default ImageOpacity;

src/core/operations/InvertImage.mjs

@@ -0,0 +1,79 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Invert Image operation
+ */
+class InvertImage extends Operation {
+
+    /**
+     * InvertImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Invert Image";
+        this.module = "Image";
+        this.description = "Invert the colours of an image.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        if (!isImage(input)) {
+            throw new OperationError("Invalid input file format.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Inverting image...");
+            image.invert();
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error inverting image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the inverted image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default InvertImage;

src/core/operations/MultipleBombe.mjs

@@ -291,7 +291,7 @@ class MultipleBombe extends Operation {
         let html = `Bombe run on menu with ${output.nLoops} loop${output.nLoops === 1 ? "" : "s"} (2+ desirable). Note: Rotors and rotor positions are listed left to right, ignore stepping and the ring setting, and positions start at the beginning of the crib. Some plugboard settings are determined. A decryption preview starting at the beginning of the crib and ignoring stepping is also provided.\n`;
 
         for (const run of output.bombeRuns) {
-            html += `\nRotors: ${run.rotors.join(", ")}\nReflector: ${run.reflector}\n`;
+            html += `\nRotors: ${run.rotors.slice().reverse().join(", ")}\nReflector: ${run.reflector}\n`;
             html += "<table class='table table-hover table-sm table-bordered table-nonfluid'><tr><th>Rotor stops</th><th>Partial plugboard</th><th>Decryption preview</th></tr>";
             for (const [setting, stecker, decrypt] of run.result) {
                 html += `<tr><td>${setting}</td><td>${stecker}</td><td>${decrypt}</td></tr>\n`;

src/core/operations/NormaliseImage.mjs

@@ -0,0 +1,70 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Normalise Image operation
+ */
+class NormaliseImage extends Operation {
+
+    /**
+     * NormaliseImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Normalise Image";
+        this.module = "Image";
+        this.description = "Normalise the image colours.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType=  "html";
+        this.args = [];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        const image = await jimp.read(Buffer.from(input));
+
+        image.normalize();
+
+        const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+        return [...imageBuffer];
+    }
+
+    /**
+     * Displays the normalised image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default NormaliseImage;

src/core/operations/ParseQRCode.mjs

@@ -6,7 +6,7 @@
 
 import Operation from "../Operation";
 import OperationError from "../errors/OperationError";
-import Magic from "../lib/Magic";
+import { isImage } from "../lib/FileType";
 import jsqr from "jsqr";
 import jimp from "jimp";
 
@@ -42,64 +42,61 @@ class ParseQRCode extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const type = Magic.magicFileType(input);
         const [normalise] = args;
 
         // Make sure that the input is an image
-        if (type && type.mime.indexOf("image") === 0) {
-            let image = input;
+        if (!isImage(input)) throw new OperationError("Invalid file type.");
 
-            if (normalise) {
-                // Process the image to be easier to read by jsqr
-                // Disables the alpha channel
-                // Sets the image default background to white
-                // Normalises the image colours
-                // Makes the image greyscale
-                // Converts image to a JPEG
-                image = await new Promise((resolve, reject) => {
-                    jimp.read(Buffer.from(input))
-                        .then(image => {
-                            image
-                                .rgba(false)
-                                .background(0xFFFFFFFF)
-                                .normalize()
-                                .greyscale()
-                                .getBuffer(jimp.MIME_JPEG, (error, result) => {
-                                    resolve(result);
-                                });
-                        })
-                        .catch(err => {
-                            reject(new OperationError("Error reading the image file."));
-                        });
-                });
-            }
+        let image = input;
 
-            if (image instanceof OperationError) {
-                throw image;
-            }
-
-            return new Promise((resolve, reject) => {
-                jimp.read(Buffer.from(image))
+        if (normalise) {
+            // Process the image to be easier to read by jsqr
+            // Disables the alpha channel
+            // Sets the image default background to white
+            // Normalises the image colours
+            // Makes the image greyscale
+            // Converts image to a JPEG
+            image = await new Promise((resolve, reject) => {
+                jimp.read(Buffer.from(input))
                     .then(image => {
-                        if (image.bitmap != null) {
-                            const qrData = jsqr(image.bitmap.data, image.getWidth(), image.getHeight());
-                            if (qrData != null) {
-                                resolve(qrData.data);
-                            } else {
-                                reject(new OperationError("Couldn't read a QR code from the image."));
-                            }
-                        } else {
-                            reject(new OperationError("Error reading the image file."));
-                        }
+                        image
+                            .rgba(false)
+                            .background(0xFFFFFFFF)
+                            .normalize()
+                            .greyscale()
+                            .getBuffer(jimp.MIME_JPEG, (error, result) => {
+                                resolve(result);
+                            });
                     })
                     .catch(err => {
                         reject(new OperationError("Error reading the image file."));
                     });
             });
-        } else {
-            throw new OperationError("Invalid file type.");
         }
 
+        if (image instanceof OperationError) {
+            throw image;
+        }
+
+        return new Promise((resolve, reject) => {
+            jimp.read(Buffer.from(image))
+                .then(image => {
+                    if (image.bitmap != null) {
+                        const qrData = jsqr(image.bitmap.data, image.getWidth(), image.getHeight());
+                        if (qrData != null) {
+                            resolve(qrData.data);
+                        } else {
+                            reject(new OperationError("Couldn't read a QR code from the image."));
+                        }
+                    } else {
+                        reject(new OperationError("Error reading the image file."));
+                    }
+                })
+                .catch(err => {
+                    reject(new OperationError("Error reading the image file."));
+                });
+        });
+
     }
 
 }

src/core/operations/PlayMedia.mjs

@@ -9,7 +9,7 @@ import { fromHex } from "../lib/Hex";
 import Operation from "../Operation";
 import OperationError from "../errors/OperationError";
 import Utils from "../Utils";
-import Magic from "../lib/Magic";
+import { isType, detectFileType } from "../lib/FileType";
 
 /**
  * PlayMedia operation
@@ -66,8 +66,7 @@ class PlayMedia extends Operation {
 
 
         // Determine file type
-        const type = Magic.magicFileType(input);
-        if (!(type && /^audio|video/.test(type.mime))) {
+        if (!isType(/^(audio|video)/, input)) {
             throw new OperationError("Invalid or unrecognised file type");
         }
 
@@ -84,15 +83,15 @@ class PlayMedia extends Operation {
     async present(data) {
         if (!data.length) return "";
 
-        const type = Magic.magicFileType(data);
-        const matches = /^audio|video/.exec(type.mime);
+        const types = detectFileType(data);
+        const matches = /^audio|video/.exec(types[0].mime);
         if (!matches) {
             throw new OperationError("Invalid file type");
         }
-        const dataURI = `data:${type.mime};base64,${toBase64(data)}`;
+        const dataURI = `data:${types[0].mime};base64,${toBase64(data)}`;
         const element = matches[0];
 
-        let html = `<${element} src='${dataURI}' type='${type.mime}' controls>`;
+        let html = `<${element} src='${dataURI}' type='${types[0].mime}' controls>`;
         html += "<p>Unsupported media type.</p>";
         html += `</${element}>`;
         return html;

src/core/operations/RenderImage.mjs

@@ -9,7 +9,7 @@ import { fromHex } from "../lib/Hex";
 import Operation from "../Operation";
 import OperationError from "../errors/OperationError";
 import Utils from "../Utils";
-import Magic from "../lib/Magic";
+import {isImage} from "../lib/FileType";
 
 /**
  * Render Image operation
@@ -72,8 +72,7 @@ class RenderImage extends Operation {
         }
 
         // Determine file type
-        const type = Magic.magicFileType(input);
-        if (!(type && type.mime.indexOf("image") === 0)) {
+        if (!isImage(input)) {
             throw new OperationError("Invalid file type");
         }
 
@@ -92,9 +91,9 @@ class RenderImage extends Operation {
         let dataURI = "data:";
 
         // Determine file type
-        const type = Magic.magicFileType(data);
-        if (type && type.mime.indexOf("image") === 0) {
-            dataURI += type.mime + ";";
+        const mime = isImage(data);
+        if (mime) {
+            dataURI += mime + ";";
         } else {
             throw new OperationError("Invalid file type");
         }

src/core/operations/ResizeImage.mjs

@@ -0,0 +1,138 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64.mjs";
+import jimp from "jimp";
+
+/**
+ * Resize Image operation
+ */
+class ResizeImage extends Operation {
+
+    /**
+     * ResizeImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Resize Image";
+        this.module = "Image";
+        this.description = "Resizes an image to the specified width and height values.";
+        this.infoURL = "https://wikipedia.org/wiki/Image_scaling";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Width",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Height",
+                type: "number",
+                value: 100,
+                min: 1
+            },
+            {
+                name: "Unit type",
+                type: "option",
+                value: ["Pixels", "Percent"]
+            },
+            {
+                name: "Maintain aspect ratio",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Resizing algorithm",
+                type: "option",
+                value: [
+                    "Nearest Neighbour",
+                    "Bilinear",
+                    "Bicubic",
+                    "Hermite",
+                    "Bezier"
+                ],
+                defaultIndex: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        let width = args[0],
+            height = args[1];
+        const unit = args[2],
+            aspect = args[3],
+            resizeAlg = args[4];
+
+        const resizeMap = {
+            "Nearest Neighbour": jimp.RESIZE_NEAREST_NEIGHBOR,
+            "Bilinear": jimp.RESIZE_BILINEAR,
+            "Bicubic": jimp.RESIZE_BICUBIC,
+            "Hermite": jimp.RESIZE_HERMITE,
+            "Bezier": jimp.RESIZE_BEZIER
+        };
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (unit === "Percent") {
+                width = image.getWidth() * (width / 100);
+                height = image.getHeight() * (height / 100);
+            }
+
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Resizing image...");
+            if (aspect) {
+                image.scaleToFit(width, height, resizeMap[resizeAlg]);
+            } else {
+                image.resize(width, height, resizeMap[resizeAlg]);
+            }
+
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error resizing image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the resized image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default ResizeImage;

src/core/operations/RotateImage.mjs

@@ -0,0 +1,87 @@
+/**
+ * @author j433866 [j433866@gmail.com]
+ * @copyright Crown Copyright 2018
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+import { isImage } from "../lib/FileType";
+import { toBase64 } from "../lib/Base64";
+import jimp from "jimp";
+
+/**
+ * Rotate Image operation
+ */
+class RotateImage extends Operation {
+
+    /**
+     * RotateImage constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Rotate Image";
+        this.module = "Image";
+        this.description = "Rotates an image by the specified number of degrees.";
+        this.infoURL = "";
+        this.inputType = "byteArray";
+        this.outputType = "byteArray";
+        this.presentType = "html";
+        this.args = [
+            {
+                name: "Rotation amount (degrees)",
+                type: "number",
+                value: 90
+            }
+        ];
+    }
+
+    /**
+     * @param {byteArray} input
+     * @param {Object[]} args
+     * @returns {byteArray}
+     */
+    async run(input, args) {
+        const [degrees] = args;
+
+        if (!isImage(input)) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        let image;
+        try {
+            image = await jimp.read(Buffer.from(input));
+        } catch (err) {
+            throw new OperationError(`Error loading image. (${err})`);
+        }
+        try {
+            if (ENVIRONMENT_IS_WORKER())
+                self.sendStatusMessage("Rotating image...");
+            image.rotate(degrees);
+            const imageBuffer = await image.getBufferAsync(jimp.AUTO);
+            return [...imageBuffer];
+        } catch (err) {
+            throw new OperationError(`Error rotating image. (${err})`);
+        }
+    }
+
+    /**
+     * Displays the rotated image using HTML for web apps
+     * @param {byteArray} data
+     * @returns {html}
+     */
+    present(data) {
+        if (!data.length) return "";
+
+        const type = isImage(data);
+        if (!type) {
+            throw new OperationError("Invalid file type.");
+        }
+
+        return `<img src="data:${type};base64,${toBase64(data)}">`;
+    }
+
+}
+
+export default RotateImage;

src/core/operations/ScanForEmbeddedFiles.mjs

@@ -6,7 +6,8 @@
 
 import Operation from "../Operation";
 import Utils from "../Utils";
-import Magic from "../lib/Magic";
+import {scanForFileTypes} from "../lib/FileType";
+import {FILE_SIGNATURES} from "../lib/FileSignatures";
 
 /**
  * Scan for Embedded Files operation
@@ -25,13 +26,13 @@ class ScanForEmbeddedFiles extends Operation {
         this.infoURL = "https://wikipedia.org/wiki/List_of_file_signatures";
         this.inputType = "ArrayBuffer";
         this.outputType = "string";
-        this.args = [
-            {
-                "name": "Ignore common byte sequences",
-                "type": "boolean",
-                "value": true
-            }
-        ];
+        this.args = Object.keys(FILE_SIGNATURES).map(cat => {
+            return {
+                name: cat,
+                type: "boolean",
+                value: cat === "Miscellaneous" ? false : true
+            };
+        });
     }
 
     /**
@@ -41,43 +42,33 @@ class ScanForEmbeddedFiles extends Operation {
      */
     run(input, args) {
         let output = "Scanning data for 'magic bytes' which may indicate embedded files. The following results may be false positives and should not be treat as reliable. Any suffiently long file is likely to contain these magic bytes coincidentally.\n",
-            type,
-            numFound = 0,
-            numCommonFound = 0;
-        const ignoreCommon = args[0],
-            commonExts = ["ico", "ttf", ""],
+            numFound = 0;
+        const categories = [],
             data = new Uint8Array(input);
 
-        for (let i = 0; i < data.length; i++) {
-            type = Magic.magicFileType(data.slice(i));
-            if (type) {
-                if (ignoreCommon && commonExts.indexOf(type.ext) > -1) {
-                    numCommonFound++;
-                    continue;
-                }
-                numFound++;
-                output += "\nOffset " + i + " (0x" + Utils.hex(i) + "):\n" +
-                    "  File extension: " + type.ext + "\n" +
-                    "  MIME type:      " + type.mime + "\n";
+        args.forEach((cat, i) => {
+            if (cat) categories.push(Object.keys(FILE_SIGNATURES)[i]);
+        });
 
-                if (type.desc && type.desc.length) {
-                    output += "  Description:    " + type.desc + "\n";
+        const types = scanForFileTypes(data, categories);
+
+        if (types.length) {
+            types.forEach(type => {
+                numFound++;
+                output += "\nOffset " + type.offset + " (0x" + Utils.hex(type.offset) + "):\n" +
+                    "  File extension: " + type.fileDetails.extension + "\n" +
+                    "  MIME type:      " + type.fileDetails.mime + "\n";
+
+                if (type.fileDetails.description && type.fileDetails.description.length) {
+                    output += "  Description:    " + type.fileDetails.description + "\n";
                 }
-            }
+            });
         }
 
         if (numFound === 0) {
             output += "\nNo embedded files were found.";
         }
 
-        if (numCommonFound > 0) {
-            output += "\n\n" + numCommonFound;
-            output += numCommonFound === 1 ?
-                " file type was detected that has a common byte sequence. This is likely to be a false positive." :
-                " file types were detected that have common byte sequences. These are likely to be false positives.";
-            output += " Run this operation with the 'Ignore common byte sequences' option unchecked to see details.";
-        }
-
         return output;
     }
 

src/core/operations/SplitColourChannels.mjs

@@ -7,7 +7,7 @@
 import Operation from "../Operation";
 import OperationError from "../errors/OperationError";
 import Utils from "../Utils";
-import Magic from "../lib/Magic";
+import {isImage} from "../lib/FileType";
 
 import jimp from "jimp";
 
@@ -38,56 +38,53 @@ class SplitColourChannels extends Operation {
      * @returns {List<File>}
      */
     async run(input, args) {
-        const type = Magic.magicFileType(input);
         // Make sure that the input is an image
-        if (type && type.mime.indexOf("image") === 0) {
-            const parsedImage = await jimp.read(Buffer.from(input));
+        if (!isImage(input)) throw new OperationError("Invalid file type.");
 
-            const red = new Promise(async (resolve, reject) => {
-                try {
-                    const split = parsedImage
-                        .clone()
-                        .color([
-                            {apply: "blue", params: [-255]},
-                            {apply: "green", params: [-255]}
-                        ])
-                        .getBufferAsync(jimp.MIME_PNG);
-                    resolve(new File([new Uint8Array((await split).values())], "red.png", {type: "image/png"}));
-                } catch (err) {
-                    reject(new OperationError(`Could not split red channel: ${err}`));
-                }
-            });
+        const parsedImage = await jimp.read(Buffer.from(input));
 
-            const green = new Promise(async (resolve, reject) => {
-                try {
-                    const split = parsedImage.clone()
-                        .color([
-                            {apply: "red", params: [-255]},
-                            {apply: "blue", params: [-255]},
-                        ]).getBufferAsync(jimp.MIME_PNG);
-                    resolve(new File([new Uint8Array((await split).values())], "green.png", {type: "image/png"}));
-                } catch (err) {
-                    reject(new OperationError(`Could not split green channel: ${err}`));
-                }
-            });
+        const red = new Promise(async (resolve, reject) => {
+            try {
+                const split = parsedImage
+                    .clone()
+                    .color([
+                        {apply: "blue", params: [-255]},
+                        {apply: "green", params: [-255]}
+                    ])
+                    .getBufferAsync(jimp.MIME_PNG);
+                resolve(new File([new Uint8Array((await split).values())], "red.png", {type: "image/png"}));
+            } catch (err) {
+                reject(new OperationError(`Could not split red channel: ${err}`));
+            }
+        });
 
-            const blue = new Promise(async (resolve, reject) => {
-                try {
-                    const split = parsedImage
-                        .color([
-                            {apply: "red", params: [-255]},
-                            {apply: "green", params: [-255]},
-                        ]).getBufferAsync(jimp.MIME_PNG);
-                    resolve(new File([new Uint8Array((await split).values())], "blue.png", {type: "image/png"}));
-                } catch (err) {
-                    reject(new OperationError(`Could not split blue channel: ${err}`));
-                }
-            });
+        const green = new Promise(async (resolve, reject) => {
+            try {
+                const split = parsedImage.clone()
+                    .color([
+                        {apply: "red", params: [-255]},
+                        {apply: "blue", params: [-255]},
+                    ]).getBufferAsync(jimp.MIME_PNG);
+                resolve(new File([new Uint8Array((await split).values())], "green.png", {type: "image/png"}));
+            } catch (err) {
+                reject(new OperationError(`Could not split green channel: ${err}`));
+            }
+        });
 
-            return await Promise.all([red, green, blue]);
-        } else {
-            throw new OperationError("Invalid file type.");
-        }
+        const blue = new Promise(async (resolve, reject) => {
+            try {
+                const split = parsedImage
+                    .color([
+                        {apply: "red", params: [-255]},
+                        {apply: "green", params: [-255]},
+                    ]).getBufferAsync(jimp.MIME_PNG);
+                resolve(new File([new Uint8Array((await split).values())], "blue.png", {type: "image/png"}));
+            } catch (err) {
+                reject(new OperationError(`Could not split blue channel: ${err}`));
+            }
+        });
+
+        return await Promise.all([red, green, blue]);
     }
 
     /**

src/core/operations/Subsection.mjs

@@ -116,7 +116,7 @@ class Subsection extends Operation {
                 }
 
                 // Baseline ing values for each tranche so that registers are reset
-                subOpList.forEach((op, i) => {
+                recipe.opList.forEach((op, i) => {
                     op.ingValues = JSON.parse(JSON.stringify(ingValues[i]));
                 });
 

src/core/operations/Untar.mjs

@@ -6,6 +6,7 @@
 
 import Operation from "../Operation";
 import Utils from "../Utils";
+import Stream from "../lib/Stream";
 
 /**
  * Untar operation
@@ -41,38 +42,6 @@ class Untar extends Operation {
      * @returns {List<File>}
      */
     run(input, args) {
-        const Stream = function(input) {
-            this.bytes = input;
-            this.position = 0;
-        };
-
-        Stream.prototype.getBytes = function(bytesToGet) {
-            const newPosition = this.position + bytesToGet;
-            const bytes = this.bytes.slice(this.position, newPosition);
-            this.position = newPosition;
-            return bytes;
-        };
-
-        Stream.prototype.readString = function(numBytes) {
-            let result = "";
-            for (let i = this.position; i < this.position + numBytes; i++) {
-                const currentByte = this.bytes[i];
-                if (currentByte === 0) break;
-                result += String.fromCharCode(currentByte);
-            }
-            this.position += numBytes;
-            return result;
-        };
-
-        Stream.prototype.readInt = function(numBytes, base) {
-            const string = this.readString(numBytes);
-            return parseInt(string, base);
-        };
-
-        Stream.prototype.hasMore = function() {
-            return this.position < this.bytes.length;
-        };
-
         const stream = new Stream(input),
             files = [];
 
@@ -85,7 +54,7 @@ class Untar extends Operation {
                 ownerUID: stream.readString(8),
                 ownerGID: stream.readString(8),
                 size: parseInt(stream.readString(12), 8), // Octal
-                lastModTime: new Date(1000 * stream.readInt(12, 8)), // Octal
+                lastModTime: new Date(1000 * parseInt(stream.readString(12), 8)), // Octal
                 checksum: stream.readString(8),
                 type: stream.readString(1),
                 linkedFileName: stream.readString(100),

src/core/operations/XPathExpression.mjs

@@ -57,7 +57,7 @@ class XPathExpression extends Operation {
 
         let nodes;
         try {
-            nodes = xpath.select(query, doc);
+            nodes = xpath.parse(query).select({ node: doc, allowAnyNamespaceForNoPrefix: true });
         } catch (err) {
             throw new OperationError(`Invalid XPath. Details:\n${err.message}.`);
         }