9.30.0

.github/workflows/master.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Install
       run: |
         npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize
 
     - name: Lint
       run: npx grunt lint
@@ -36,9 +36,9 @@ jobs:
     - name: Generate sitemap
       run: npx grunt exec:sitemap
 
-    - name: UI Tests
-      if: success()
-      run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
+    # - name: UI Tests
+    #   if: success()
+    #   run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
 
     - name: Prepare for GitHub Pages
       if: success()

.github/workflows/pull_requests.yml

@@ -18,7 +18,7 @@ jobs:
     - name: Install
       run: |
         npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize
 
     - name: Lint
       run: npx grunt lint
@@ -32,6 +32,6 @@ jobs:
       if: success()
       run: npx grunt prod
 
-    - name: UI Tests
-      if: success()
-      run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
+    # - name: UI Tests
+    #   if: success()
+    #   run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui

.github/workflows/releases.yml

@@ -19,7 +19,7 @@ jobs:
     - name: Install
       run: |
         npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize
 
     - name: Lint
       run: npx grunt lint
@@ -33,9 +33,9 @@ jobs:
       if: success()
       run: npx grunt prod
 
-    - name: UI Tests
-      if: success()
-      run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
+    # - name: UI Tests
+    #   if: success()
+    #   run: xvfb-run --server-args="-screen 0 1200x800x24" npx grunt testui
 
     - name: Upload Release Assets
       if: success()

CHANGELOG.md

@@ -13,6 +13,18 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.30.0] - 2021-08-10
+- 'JA3S Fingerprint' operation added [@n1474335] | [289a417d]
+
+### [9.29.0] - 2021-07-28
+- 'JA3 Fingerprint' operation added [@n1474335] | [9a33498]
+
+### [9.28.0] - 2021-03-26
+- 'CBOR Encode' and 'CBOR Decode' operations added [@Danh4] | [#999]
+
+### [9.27.0] - 2021-02-12
+- 'Fuzzy Match' operation added [@n1474335] | [8ad18b]
+
 ### [9.26.0] - 2021-02-11
 - 'Get Time' operation added [@n1073645] [@n1474335] | [#1045]
 
@@ -253,6 +265,10 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.30.0]: https://github.com/gchq/CyberChef/releases/tag/v9.30.0
+[9.29.0]: https://github.com/gchq/CyberChef/releases/tag/v9.29.0
+[9.28.0]: https://github.com/gchq/CyberChef/releases/tag/v9.28.0
+[9.27.0]: https://github.com/gchq/CyberChef/releases/tag/v9.27.0
 [9.26.0]: https://github.com/gchq/CyberChef/releases/tag/v9.26.0
 [9.25.0]: https://github.com/gchq/CyberChef/releases/tag/v9.25.0
 [9.24.0]: https://github.com/gchq/CyberChef/releases/tag/v9.24.0
@@ -359,6 +375,11 @@ All major and minor version changes will be documented in this file. Details of
 [@MarvinJWendt]: https://github.com/MarvinJWendt
 [@dmfj]: https://github.com/dmfj
 [@mattnotmitt]: https://github.com/mattnotmitt
+[@Danh4]: https://github.com/Danh4
+
+[8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
+[9a33498]: https://github.com/gchq/CyberChef/commit/9a33498fed26a8df9c9f35f39a78a174bf50a513
+[289a417d]: https://github.com/gchq/CyberChef/commit/289a417d
 
 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -432,6 +453,7 @@ All major and minor version changes will be documented in this file. Details of
 [#965]: https://github.com/gchq/CyberChef/pull/965
 [#966]: https://github.com/gchq/CyberChef/pull/966
 [#987]: https://github.com/gchq/CyberChef/pull/987
+[#999]: https://github.com/gchq/CyberChef/pull/999
 [#1006]: https://github.com/gchq/CyberChef/pull/1006
 [#1022]: https://github.com/gchq/CyberChef/pull/1022
 [#1045]: https://github.com/gchq/CyberChef/pull/1045

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.26.2",
+  "version": "9.30.0",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",
@@ -43,12 +43,12 @@
     "babel-eslint": "^10.1.0",
     "babel-loader": "^8.2.2",
     "babel-plugin-dynamic-import-node": "^2.3.3",
-    "chromedriver": "^88.0.0",
+    "chromedriver": "^92.0.0",
     "cli-progress": "^3.9.0",
     "colors": "^1.4.0",
     "copy-webpack-plugin": "^7.0.0",
     "css-loader": "^5.0.2",
-    "eslint": "^7.19.0",
+    "eslint": "^7.20.0",
     "exports-loader": "^2.0.0",
     "file-loader": "^6.2.0",
     "grunt": "^1.3.0",
@@ -64,8 +64,8 @@
     "grunt-zip": "^0.18.2",
     "html-webpack-plugin": "^5.1.0",
     "imports-loader": "^2.0.0",
-    "mini-css-extract-plugin": "^1.3.6",
-    "nightwatch": "^1.5.1",
+    "mini-css-extract-plugin": "^1.3.7",
+    "nightwatch": "^1.7.7",
     "node-sass": "^5.0.0",
     "postcss": "^8.2.6",
     "postcss-css-variables": "^0.17.0",
@@ -77,10 +77,10 @@
     "style-loader": "^2.0.0",
     "svg-url-loader": "^7.1.1",
     "url-loader": "^4.1.1",
-    "webpack": "^5.21.2",
+    "webpack": "^5.22.0",
     "webpack-bundle-analyzer": "^4.4.0",
     "webpack-dev-server": "^3.11.2",
-    "webpack-node-externals": "^2.5.2",
+    "webpack-node-externals": "^3.0.0",
     "worker-loader": "^3.0.8"
   },
   "dependencies": {
@@ -98,6 +98,7 @@
     "browserify-zlib": "^0.2.0",
     "bson": "^4.2.2",
     "buffer": "^6.0.3",
+    "cbor": "^5.0.1",
     "chi-squared": "^1.1.0",
     "codepage": "^1.14.0",
     "core-js": "^3.8.3",
@@ -122,14 +123,14 @@
     "js-crc": "^0.2.0",
     "js-sha3": "^0.8.0",
     "jsesc": "^3.0.2",
-    "jsonpath": "^1.1.0",
+    "jsonpath": "^1.1.1",
     "jsonwebtoken": "^8.5.1",
     "jsqr": "^1.3.1",
-    "jsrsasign": "10.1.8",
+    "jsrsasign": "^10.3.0",
     "kbpgp": "2.1.15",
     "libbzip2-wasm": "0.0.4",
     "libyara-wasm": "^1.1.0",
-    "lodash": "^4.17.20",
+    "lodash": "^4.17.21",
     "loglevel": "^1.7.1",
     "loglevel-message-prefix": "^3.0.0",
     "markdown-it": "^12.0.4",
@@ -152,13 +153,13 @@
     "split.js": "^1.6.2",
     "ssdeep.js": "0.0.2",
     "stream-browserify": "^3.0.0",
-    "terser": "^5.5.1",
+    "terser": "^5.6.0",
     "tesseract.js": "2.1.1",
     "ua-parser-js": "^0.7.24",
     "unorm": "^1.6.0",
     "utf8": "^3.0.0",
     "vkbeautify": "^0.99.3",
-    "xmldom": "^0.4.0",
+    "xmldom": "^0.6.0",
     "xpath": "0.0.32",
     "xregexp": "^5.0.1",
     "zlibjs": "^0.3.1"
@@ -173,6 +174,8 @@
     "testuidev": "npx nightwatch --env=dev",
     "lint": "npx grunt lint",
     "postinstall": "npx grunt exec:fixCryptoApiImports",
-    "newop": "node --experimental-modules src/core/config/scripts/newOperation.mjs"
+    "newop": "node --experimental-modules src/core/config/scripts/newOperation.mjs",
+    "getheapsize": "node -e 'console.log(`node heap limit = ${require(\"v8\").getHeapStatistics().heap_size_limit / (1024 * 1024)} Mb`)'",
+    "setheapsize": "export NODE_OPTIONS=--max_old_space_size=2048"
   }
 }

src/core/Utils.mjs

@@ -895,8 +895,8 @@ class Utils {
 
         while ((m = recipeRegex.exec(recipe))) {
             // Translate strings in args back to double-quotes
-            args = m[2]
-                .replace(/"/g, '\\"') // Escape double quotes // lgtm [js/incomplete-sanitization]
+            args = m[2] // lgtm [js/incomplete-sanitization]
+                .replace(/"/g, '\\"') // Escape double quotes
                 .replace(/(^|,|{|:)'/g, '$1"') // Replace opening ' with "
                 .replace(/([^\\]|(?:\\\\)+)'(,|:|}|$)/g, '$1"$2') // Replace closing ' with "
                 .replace(/\\'/g, "'"); // Unescape single quotes

src/core/config/Categories.json

@@ -61,7 +61,9 @@
             "Parse TLV",
             "CSV to JSON",
             "JSON to CSV",
-            "Avro to JSON"
+            "Avro to JSON",
+            "CBOR Encode",
+            "CBOR Decode"
         ]
     },
     {
@@ -191,6 +193,8 @@
             "Protobuf Decode",
             "VarInt Encode",
             "VarInt Decode",
+            "JA3 Fingerprint",
+            "JA3S Fingerprint",
             "Format MAC addresses",
             "Change IP format",
             "Group IP addresses",
@@ -238,6 +242,7 @@
             "Pad lines",
             "Find / Replace",
             "Regular expression",
+            "Fuzzy Match",
             "Offset checker",
             "Hamming Distance",
             "Convert distance",

src/core/lib/Base64.mjs

@@ -148,4 +148,8 @@ export const ALPHABET_OPTIONS = [
     {name: "BinHex: !-,-0-689@A-NP-VX-Z[`a-fh-mp-r", value: "!-,-0-689@A-NP-VX-Z[`a-fh-mp-r"},
     {name: "ROT13: N-ZA-Mn-za-m0-9+/=", value: "N-ZA-Mn-za-m0-9+/="},
     {name: "UNIX crypt: ./0-9A-Za-z", value: "./0-9A-Za-z"},
+    {name: "Atom128: /128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC", value: "/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC"},
+    {name: "Megan35: 3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5", value: "3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5"},
+    {name: "Zong22: ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2", value: "ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2"},
+    {name: "Hazz15: HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5", value: "HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5"}
 ];

src/core/lib/Binary.mjs

@@ -7,6 +7,7 @@
  */
 
 import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
 
 
 /**
@@ -58,6 +59,9 @@ export function toBinary(data, delim="Space", padding=8) {
  * fromBinary("00010000:00100000:00110000", "Colon");
  */
 export function fromBinary(data, delim="Space", byteLen=8) {
+    if (byteLen < 1 || Math.round(byteLen) !== byteLen)
+        throw new OperationError("Byte length must be a positive integer");
+
     const delimRegex = Utils.regexRep(delim);
     data = data.replace(delimRegex, "");
 

src/core/lib/FuzzyMatch.mjs

@@ -16,40 +16,72 @@
  *   Anurag Awasthi - updated to 0.2.0
  */
 
-const SEQUENTIAL_BONUS = 15; // bonus for adjacent matches
-const SEPARATOR_BONUS = 30; // bonus if match occurs after a separator
-const CAMEL_BONUS = 30; // bonus if match is uppercase and prev is lower
-const FIRST_LETTER_BONUS = 15; // bonus if the first letter is matched
+export const DEFAULT_WEIGHTS = {
+    sequentialBonus: 15, // bonus for adjacent matches
+    separatorBonus: 30, // bonus if match occurs after a separator
+    camelBonus: 30, // bonus if match is uppercase and prev is lower
+    firstLetterBonus: 15, // bonus if the first letter is matched
 
-const LEADING_LETTER_PENALTY = -5; // penalty applied for every letter in str before the first match
-const MAX_LEADING_LETTER_PENALTY = -15; // maximum penalty for leading letters
-const UNMATCHED_LETTER_PENALTY = -1;
+    leadingLetterPenalty: -5, // penalty applied for every letter in str before the first match
+    maxLeadingLetterPenalty: -15, // maximum penalty for leading letters
+    unmatchedLetterPenalty: -1
+};
 
 /**
  * Does a fuzzy search to find pattern inside a string.
- * @param {*} pattern string        pattern to search for
- * @param {*} str     string        string which is being searched
+ * @param {string} pattern        pattern to search for
+ * @param {string} str            string which is being searched
+ * @param {boolean} global        whether to search for all matches or just one
  * @returns [boolean, number]       a boolean which tells if pattern was
  *                                  found or not and a search score
  */
-export function fuzzyMatch(pattern, str) {
+export function fuzzyMatch(pattern, str, global=false, weights=DEFAULT_WEIGHTS) {
     const recursionCount = 0;
     const recursionLimit = 10;
     const matches = [];
     const maxMatches = 256;
 
-    return fuzzyMatchRecursive(
-        pattern,
-        str,
-        0 /* patternCurIndex */,
-        0 /* strCurrIndex */,
-        null /* srcMatces */,
-        matches,
-        maxMatches,
-        0 /* nextMatch */,
-        recursionCount,
-        recursionLimit
-    );
+    if (!global) {
+        return fuzzyMatchRecursive(
+            pattern,
+            str,
+            0 /* patternCurIndex */,
+            0 /* strCurrIndex */,
+            null /* srcMatches */,
+            matches,
+            maxMatches,
+            0 /* nextMatch */,
+            recursionCount,
+            recursionLimit,
+            weights
+        );
+    }
+
+    // Return all matches
+    let foundMatch = true,
+        score,
+        idxs,
+        strCurrIndex = 0;
+    const results = [];
+
+    while (foundMatch) {
+        [foundMatch, score, idxs] = fuzzyMatchRecursive(
+            pattern,
+            str,
+            0 /* patternCurIndex */,
+            strCurrIndex,
+            null /* srcMatches */,
+            matches,
+            maxMatches,
+            0 /* nextMatch */,
+            recursionCount,
+            recursionLimit,
+            weights
+        );
+        if (foundMatch) results.push([foundMatch, score, [...idxs]]);
+        strCurrIndex = idxs[idxs.length - 1] + 1;
+    }
+    return results;
 }
 
 /**
@@ -65,7 +97,8 @@ function fuzzyMatchRecursive(
     maxMatches,
     nextMatch,
     recursionCount,
-    recursionLimit
+    recursionLimit,
+    weights
 ) {
     let outScore = 0;
 
@@ -110,7 +143,8 @@ function fuzzyMatchRecursive(
                 maxMatches,
                 nextMatch,
                 recursionCount,
-                recursionLimit
+                recursionLimit,
+                weights
             );
 
             if (matched) {
@@ -134,16 +168,16 @@ function fuzzyMatchRecursive(
         outScore = 100;
 
         // Apply leading letter penalty
-        let penalty = LEADING_LETTER_PENALTY * matches[0];
+        let penalty = weights.leadingLetterPenalty * matches[0];
         penalty =
-            penalty < MAX_LEADING_LETTER_PENALTY ?
-                MAX_LEADING_LETTER_PENALTY :
+            penalty < weights.maxLeadingLetterPenalty ?
+                weights.maxLeadingLetterPenalty :
                 penalty;
         outScore += penalty;
 
         // Apply unmatched penalty
         const unmatched = str.length - nextMatch;
-        outScore += UNMATCHED_LETTER_PENALTY * unmatched;
+        outScore += weights.unmatchedLetterPenalty * unmatched;
 
         // Apply ordering bonuses
         for (let i = 0; i < nextMatch; i++) {
@@ -152,7 +186,7 @@ function fuzzyMatchRecursive(
             if (i > 0) {
                 const prevIdx = matches[i - 1];
                 if (currIdx === prevIdx + 1) {
-                    outScore += SEQUENTIAL_BONUS;
+                    outScore += weights.sequentialBonus;
                 }
             }
 
@@ -165,15 +199,15 @@ function fuzzyMatchRecursive(
                     neighbor !== neighbor.toUpperCase() &&
                     curr !== curr.toLowerCase()
                 ) {
-                    outScore += CAMEL_BONUS;
+                    outScore += weights.camelBonus;
                 }
                 const isNeighbourSeparator = neighbor === "_" || neighbor === " ";
                 if (isNeighbourSeparator) {
-                    outScore += SEPARATOR_BONUS;
+                    outScore += weights.separatorBonus;
                 }
             } else {
                 // First letter
-                outScore += FIRST_LETTER_BONUS;
+                outScore += weights.firstLetterBonus;
             }
         }
 

src/core/lib/Hex.mjs

@@ -7,6 +7,7 @@
  */
 
 import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
 
 
 /**
@@ -100,6 +101,9 @@ export function toHexFast(data) {
  * fromHex("0a:14:1e", "Colon");
  */
 export function fromHex(data, delim="Auto", byteLen=2) {
+    if (byteLen < 1 || Math.round(byteLen) !== byteLen)
+        throw new OperationError("Byte length must be a positive integer");
+
     if (delim !== "None") {
         const delimRegex = delim === "Auto" ? /[^a-f\d]|(0x)/gi : Utils.regexRep(delim);
         data = data.replace(delimRegex, "");

src/core/lib/PublicKey.mjs

@@ -15,7 +15,7 @@ import { toHex, fromHex } from "./Hex.mjs";
  * @param {number} indent
  * @returns {string}
  */
-export function formatDnStr (dnStr, indent) {
+export function formatDnStr(dnStr, indent) {
     const fields = dnStr.substr(1).replace(/([^\\])\//g, "$1$1/").split(/[^\\]\//);
     let output = "",
         maxKeyLen = 0,
@@ -54,7 +54,7 @@ export function formatDnStr (dnStr, indent) {
  * @param {number} indent
  * @returns {string}
  */
-export function formatByteStr (byteStr, length, indent) {
+export function formatByteStr(byteStr, length, indent) {
     byteStr = toHex(fromHex(byteStr), ":");
     length = length * 3;
     let output = "";

src/core/operations/AESDecrypt.mjs

@@ -87,8 +87,9 @@ class AESDecrypt extends Operation {
             },
             {
                 "name": "Additional Authenticated Data",
-                "type": "binaryString",
-                "value": ""
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
             }
         ];
     }
@@ -107,7 +108,7 @@ class AESDecrypt extends Operation {
             inputType = args[3],
             outputType = args[4],
             gcmTag = Utils.convertToByteString(args[5].string, args[5].option),
-            aad = args[6];
+            aad = Utils.convertToByteString(args[6].string, args[6].option);
 
         if ([16, 24, 32].indexOf(key.length) < 0) {
             throw new OperationError(`Invalid key length: ${key.length} bytes

src/core/operations/AESEncrypt.mjs

@@ -81,8 +81,9 @@ class AESEncrypt extends Operation {
             },
             {
                 "name": "Additional Authenticated Data",
-                "type": "binaryString",
-                "value": ""
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
             }
         ];
     }
@@ -100,7 +101,7 @@ class AESEncrypt extends Operation {
             mode = args[2],
             inputType = args[3],
             outputType = args[4],
-            aad = args[5];
+            aad = Utils.convertToByteString(args[5].string, args[5].option);
 
         if ([16, 24, 32].indexOf(key.length) < 0) {
             throw new OperationError(`Invalid key length: ${key.length} bytes

src/core/operations/CBORDecode.mjs

@@ -0,0 +1,41 @@
+/**
+ * @author Danh4 [dan.h4@ncsc.gov.uk]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Cbor from "cbor";
+
+/**
+ * CBOR Decode operation
+ */
+class CBORDecode extends Operation {
+
+    /**
+     * CBORDecode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CBOR Decode";
+        this.module = "Serialise";
+        this.description = "Concise Binary Object Representation (CBOR) is a binary data serialization format loosely based on JSON. Like JSON it allows the transmission of data objects that contain name–value pairs, but in a more concise manner. This increases processing and transfer speeds at the cost of human readability. It is defined in IETF RFC 8949.";
+        this.infoURL = "https://wikipedia.org/wiki/CBOR";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "JSON";
+        this.args = [];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {JSON}
+     */
+    run(input, args) {
+        return Cbor.decodeFirstSync(Buffer.from(input).toString("hex"));
+    }
+
+}
+
+export default CBORDecode;

src/core/operations/CBOREncode.mjs

@@ -0,0 +1,41 @@
+/**
+ * @author Danh4 [dan.h4@ncsc.gov.uk]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Cbor from "cbor";
+
+/**
+ * CBOR Encode operation
+ */
+class CBOREncode extends Operation {
+
+    /**
+     * CBOREncode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CBOR Encode";
+        this.module = "Serialise";
+        this.description = "Concise Binary Object Representation (CBOR) is a binary data serialization format loosely based on JSON. Like JSON it allows the transmission of data objects that contain name–value pairs, but in a more concise manner. This increases processing and transfer speeds at the cost of human readability. It is defined in IETF RFC 8949.";
+        this.infoURL = "https://wikipedia.org/wiki/CBOR";
+        this.inputType = "JSON";
+        this.outputType = "ArrayBuffer";
+        this.args = [];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        return new Uint8Array(Cbor.encodeCanonical(input)).buffer;
+    }
+
+}
+
+export default CBOREncode;

src/core/operations/ExtractFiles.mjs

@@ -21,9 +21,24 @@ class ExtractFiles extends Operation {
     constructor() {
         super();
 
+        // Get the first extension for each signature that can be extracted
+        let supportedExts = Object.keys(FILE_SIGNATURES).map(cat => {
+            return FILE_SIGNATURES[cat]
+                .filter(sig => sig.extractor)
+                .map(sig => sig.extension.toUpperCase());
+        });
+
+        // Flatten categories and remove duplicates
+        supportedExts = [].concat(...supportedExts).unique();
+
         this.name = "Extract Files";
         this.module = "Default";
-        this.description = "Performs file carving to attempt to extract files from the input.<br><br>This operation is currently capable of carving out the following formats:<ul><li>JPG</li><li>EXE</li><li>ZIP</li><li>PDF</li><li>PNG</li><li>BMP</li><li>FLV</li><li>RTF</li><li>DOCX, PPTX, XLSX</li><li>EPUB</li><li>GZIP</li><li>ZLIB</li><li>ELF, BIN, AXF, O, PRX, SO</li></ul>";
+        this.description = `Performs file carving to attempt to extract files from the input.<br><br>This operation is currently capable of carving out the following formats:
+            <ul>
+                <li>
+                ${supportedExts.join("</li><li>")}
+                </li>
+            </ul>`;
         this.infoURL = "https://forensicswiki.xyz/wiki/index.php?title=File_Carving";
         this.inputType = "ArrayBuffer";
         this.outputType = "List<File>";

src/core/operations/FromBase64.mjs

@@ -102,6 +102,26 @@ class FromBase64 extends Operation {
                 flags: "i",
                 args: ["./0-9A-Za-z", true]
             },
+            {
+                pattern: "^\\s*(?:[A-Z=\\d\\+/]{4}){5,}(?:[A-Z=\\d\\+/]{2}CC|[A-Z=\\d\\+/]{3}C)?\\s*$",
+                flags: "i",
+                args: ["/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC", true]
+            },
+            {
+                pattern: "^\\s*(?:[A-Z=\\d\\+/]{4}){5,}(?:[A-Z=\\d\\+/]{2}55|[A-Z=\\d\\+/]{3}5)?\\s*$",
+                flags: "i",
+                args: ["3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5", true]
+            },
+            {
+                pattern: "^\\s*(?:[A-Z=\\d\\+/]{4}){5,}(?:[A-Z=\\d\\+/]{2}22|[A-Z=\\d\\+/]{3}2)?\\s*$",
+                flags: "i",
+                args: ["ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2", true]
+            },
+            {
+                pattern: "^\\s*(?:[A-Z=\\d\\+/]{4}){5,}(?:[A-Z=\\d\\+/]{2}55|[A-Z=\\d\\+/]{3}5)?\\s*$",
+                flags: "i",
+                args: ["HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5", true]
+            }
         ];
     }
 

src/core/operations/FromBinary.mjs

@@ -35,7 +35,8 @@ class FromBinary extends Operation {
             {
                 "name": "Byte Length",
                 "type": "number",
-                "value": 8
+                "value": 8,
+                "min": 1
             }
         ];
         this.checks = [

src/core/operations/FuzzyMatch.mjs

@@ -0,0 +1,121 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {fuzzyMatch, calcMatchRanges, DEFAULT_WEIGHTS} from "../lib/FuzzyMatch.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * Fuzzy Match operation
+ */
+class FuzzyMatch extends Operation {
+
+    /**
+     * FuzzyMatch constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fuzzy Match";
+        this.module = "Default";
+        this.description = "Conducts a fuzzy search to find a pattern within the input based on weighted criteria.<br><br>e.g. A search for <code>dpan</code> will match on <code><b>D</b>on't <b>Pan</b>ic</code>";
+        this.infoURL = "https://wikipedia.org/wiki/Fuzzy_matching_(computer-assisted_translation)";
+        this.inputType = "string";
+        this.outputType = "html";
+        this.args = [
+            {
+                name: "Search",
+                type: "binaryString",
+                value: ""
+            },
+            {
+                name: "Sequential bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.sequentialBonus,
+                hint: "Bonus for adjacent matches"
+            },
+            {
+                name: "Separator bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.separatorBonus,
+                hint: "Bonus if match occurs after a separator"
+            },
+            {
+                name: "Camel bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.camelBonus,
+                hint: "Bonus if match is uppercase and previous is lower"
+            },
+            {
+                name: "First letter bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.firstLetterBonus,
+                hint: "Bonus if the first letter is matched"
+            },
+            {
+                name: "Leading letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.leadingLetterPenalty,
+                hint: "Penalty applied for every letter in the input before the first match"
+            },
+            {
+                name: "Max leading letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.maxLeadingLetterPenalty,
+                hint: "Maxiumum penalty for leading letters"
+            },
+            {
+                name: "Unmatched letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.unmatchedLetterPenalty
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {html}
+     */
+    run(input, args) {
+        const searchStr = args[0];
+        const weights = {
+            sequentialBonus: args[1],
+            separatorBonus: args[2],
+            camelBonus: args[3],
+            firstLetterBonus: args[4],
+            leadingLetterPenalty: args[5],
+            maxLeadingLetterPenalty: args[6],
+            unmatchedLetterPenalty: args[7]
+        };
+        const matches = fuzzyMatch(searchStr, input, true, weights);
+
+        if (!matches) {
+            return "No matches.";
+        }
+
+        let result = "", pos = 0, hlClass = "hl1";
+        matches.forEach(([matches, score, idxs]) => {
+            const matchRanges = calcMatchRanges(idxs);
+
+            matchRanges.forEach(([start, length], i) => {
+                result += Utils.escapeHtml(input.slice(pos, start));
+                if (i === 0) result += `<span class="${hlClass}">`;
+                pos = start + length;
+                result += `<b>${Utils.escapeHtml(input.slice(start, pos))}</b>`;
+            });
+            result += "</span>";
+            hlClass = hlClass === "hl1" ? "hl2" : "hl1";
+        });
+
+        result += Utils.escapeHtml(input.slice(pos, input.length));
+
+        return result;
+    }
+
+}
+
+export default FuzzyMatch;

src/core/operations/JA3Fingerprint.mjs

@@ -0,0 +1,205 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ *
+ * JA3 created by Salesforce
+ *   John B. Althouse
+ *   Jeff Atkinson
+ *   Josh Atkins
+ *
+ * Algorithm released under the BSD-3-clause licence
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import Stream from "../lib/Stream.mjs";
+import {runHash} from "../lib/Hash.mjs";
+
+/**
+ * JA3 Fingerprint operation
+ */
+class JA3Fingerprint extends Operation {
+
+    /**
+     * JA3Fingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JA3 Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a JA3 fingerprint to help identify TLS clients based on hashing together values from the Client Hello.<br><br>Input: A hex stream of the TLS Client Hello application layer.";
+        this.infoURL = "https://engineering.salesforce.com/tls-fingerprinting-with-ja3-and-ja3s-247362855967";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input format",
+                type: "option",
+                value: ["Hex", "Base64", "Raw"]
+            },
+            {
+                name: "Output format",
+                type: "option",
+                value: ["Hash digest", "JA3 string", "Full details"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [inputFormat, outputFormat] = args;
+
+        input = Utils.convertToByteArray(input, inputFormat);
+        const s = new Stream(new Uint8Array(input));
+
+        const handshake = s.readInt(1);
+        if (handshake !== 0x16)
+            throw new OperationError("Not handshake data.");
+
+        // Version
+        s.moveForwardsBy(2);
+
+        // Length
+        const length = s.readInt(2);
+        if (s.length !== length + 5)
+            throw new OperationError("Incorrect handshake length.");
+
+        // Handshake type
+        const handshakeType = s.readInt(1);
+        if (handshakeType !== 1)
+            throw new OperationError("Not a Client Hello.");
+
+        // Handshake length
+        const handshakeLength = s.readInt(3);
+        if (s.length !== handshakeLength + 9)
+            throw new OperationError("Not enough data in Client Hello.");
+
+        // Hello version
+        const helloVersion = s.readInt(2);
+
+        // Random
+        s.moveForwardsBy(32);
+
+        // Session ID
+        const sessionIDLength = s.readInt(1);
+        s.moveForwardsBy(sessionIDLength);
+
+        // Cipher suites
+        const cipherSuitesLength = s.readInt(2);
+        const cipherSuites = s.getBytes(cipherSuitesLength);
+        const cs = new Stream(cipherSuites);
+        const cipherSegment = parseJA3Segment(cs, 2);
+
+        // Compression Methods
+        const compressionMethodsLength = s.readInt(1);
+        s.moveForwardsBy(compressionMethodsLength);
+
+        // Extensions
+        const extensionsLength = s.readInt(2);
+        const extensions = s.getBytes(extensionsLength);
+        const es = new Stream(extensions);
+        let ecsLen, ecs, ellipticCurves = "", ellipticCurvePointFormats = "";
+        const exts = [];
+        while (es.hasMore()) {
+            const type = es.readInt(2);
+            const length = es.readInt(2);
+            switch (type) {
+                case 0x0a: // Elliptic curves
+                    ecsLen = es.readInt(2);
+                    ecs = new Stream(es.getBytes(ecsLen));
+                    ellipticCurves = parseJA3Segment(ecs, 2);
+                    break;
+                case 0x0b: // Elliptic curve point formats
+                    ecsLen = es.readInt(1);
+                    ecs = new Stream(es.getBytes(ecsLen));
+                    ellipticCurvePointFormats = parseJA3Segment(ecs, 1);
+                    break;
+                default:
+                    es.moveForwardsBy(length);
+            }
+            if (!GREASE_CIPHERSUITES.includes(type))
+                exts.push(type);
+        }
+
+        // Output
+        const ja3 = [
+            helloVersion.toString(),
+            cipherSegment,
+            exts.join("-"),
+            ellipticCurves,
+            ellipticCurvePointFormats
+        ];
+        const ja3Str = ja3.join(",");
+        const ja3Hash = runHash("md5", Utils.strToArrayBuffer(ja3Str));
+
+        switch (outputFormat) {
+            case "JA3 string":
+                return ja3Str;
+            case "Full details":
+                return `Hash digest:
+${ja3Hash}
+
+Full JA3 string:
+${ja3Str}
+
+TLS Version:
+${helloVersion.toString()}
+Cipher Suites:
+${cipherSegment}
+Extensions:
+${exts.join("-")}
+Elliptic Curves:
+${ellipticCurves}
+Elliptic Curve Point Formats:
+${ellipticCurvePointFormats}`;
+            case "Hash digest":
+            default:
+                return ja3Hash;
+        }
+    }
+
+}
+
+/**
+ * Parses a JA3 segment, returning a "-" separated list
+ *
+ * @param {Stream} stream
+ * @returns {string}
+ */
+function parseJA3Segment(stream, size=2) {
+    const segment = [];
+    while (stream.hasMore()) {
+        const element = stream.readInt(size);
+        if (!GREASE_CIPHERSUITES.includes(element))
+            segment.push(element);
+    }
+    return segment.join("-");
+}
+
+const GREASE_CIPHERSUITES = [
+    0x0a0a,
+    0x1a1a,
+    0x2a2a,
+    0x3a3a,
+    0x4a4a,
+    0x5a5a,
+    0x6a6a,
+    0x7a7a,
+    0x8a8a,
+    0x9a9a,
+    0xaaaa,
+    0xbaba,
+    0xcaca,
+    0xdada,
+    0xeaea,
+    0xfafa
+];
+
+export default JA3Fingerprint;

src/core/operations/JA3SFingerprint.mjs

@@ -0,0 +1,145 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ *
+ * JA3S created by Salesforce
+ *   John B. Althouse
+ *   Jeff Atkinson
+ *   Josh Atkins
+ *
+ * Algorithm released under the BSD-3-clause licence
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Utils from "../Utils.mjs";
+import Stream from "../lib/Stream.mjs";
+import {runHash} from "../lib/Hash.mjs";
+
+/**
+ * JA3S Fingerprint operation
+ */
+class JA3SFingerprint extends Operation {
+
+    /**
+     * JA3SFingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "JA3S Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a JA3S fingerprint to help identify TLS servers based on hashing together values from the Server Hello.<br><br>Input: A hex stream of the TLS Server Hello record in the application layer.";
+        this.infoURL = "https://engineering.salesforce.com/tls-fingerprinting-with-ja3-and-ja3s-247362855967";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                name: "Input format",
+                type: "option",
+                value: ["Hex", "Base64", "Raw"]
+            },
+            {
+                name: "Output format",
+                type: "option",
+                value: ["Hash digest", "JA3S string", "Full details"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const [inputFormat, outputFormat] = args;
+
+        input = Utils.convertToByteArray(input, inputFormat);
+        const s = new Stream(new Uint8Array(input));
+
+        const handshake = s.readInt(1);
+        if (handshake !== 0x16)
+            throw new OperationError("Not handshake data.");
+
+        // Version
+        s.moveForwardsBy(2);
+
+        // Length
+        const length = s.readInt(2);
+        if (s.length !== length + 5)
+            throw new OperationError("Incorrect handshake length.");
+
+        // Handshake type
+        const handshakeType = s.readInt(1);
+        if (handshakeType !== 2)
+            throw new OperationError("Not a Server Hello.");
+
+        // Handshake length
+        const handshakeLength = s.readInt(3);
+        if (s.length !== handshakeLength + 9)
+            throw new OperationError("Not enough data in Server Hello.");
+
+        // Hello version
+        const helloVersion = s.readInt(2);
+
+        // Random
+        s.moveForwardsBy(32);
+
+        // Session ID
+        const sessionIDLength = s.readInt(1);
+        s.moveForwardsBy(sessionIDLength);
+
+        // Cipher suite
+        const cipherSuite = s.readInt(2);
+
+        // Compression Method
+        s.moveForwardsBy(1);
+
+        // Extensions
+        const extensionsLength = s.readInt(2);
+        const extensions = s.getBytes(extensionsLength);
+        const es = new Stream(extensions);
+        const exts = [];
+        while (es.hasMore()) {
+            const type = es.readInt(2);
+            const length = es.readInt(2);
+            es.moveForwardsBy(length);
+            exts.push(type);
+        }
+
+        // Output
+        const ja3s = [
+            helloVersion.toString(),
+            cipherSuite,
+            exts.join("-")
+        ];
+        const ja3sStr = ja3s.join(",");
+        const ja3sHash = runHash("md5", Utils.strToArrayBuffer(ja3sStr));
+
+        switch (outputFormat) {
+            case "JA3S string":
+                return ja3sStr;
+            case "Full details":
+                return `Hash digest:
+${ja3sHash}
+
+Full JA3S string:
+${ja3sStr}
+
+TLS Version:
+${helloVersion.toString()}
+Cipher Suite:
+${cipherSuite}
+Extensions:
+${exts.join("-")}`;
+            case "Hash digest":
+            default:
+                return ja3sHash;
+        }
+    }
+
+}
+
+export default JA3SFingerprint;

src/core/operations/JSONToCSV.mjs

@@ -43,15 +43,16 @@ class JSONToCSV extends Operation {
     /**
      * Converts JSON to a CSV equivalent.
      *
+     * @param {boolean} force - Whether to force conversion of data to fit in a cell
      * @returns {string}
      */
-    toCSV() {
+    toCSV(force=false) {
         const self = this;
         // If the JSON is an array of arrays, this is easy
         if (this.flattened[0] instanceof Array) {
             return this.flattened
                 .map(row => row
-                    .map(self.escapeCellContents.bind(self))
+                    .map(d => self.escapeCellContents(d, force))
                     .join(this.cellDelim)
                 )
                 .join(this.rowDelim) +
@@ -61,13 +62,13 @@ class JSONToCSV extends Operation {
         // If it's an array of dictionaries...
         const header = Object.keys(this.flattened[0]);
         return header
-            .map(self.escapeCellContents.bind(self))
+            .map(d => self.escapeCellContents(d, force))
             .join(this.cellDelim) +
             this.rowDelim +
             this.flattened
                 .map(row => header
                     .map(h => row[h])
-                    .map(self.escapeCellContents.bind(self))
+                    .map(d => self.escapeCellContents(d, force))
                     .join(this.cellDelim)
                 )
                 .join(this.rowDelim) +
@@ -98,7 +99,7 @@ class JSONToCSV extends Operation {
                 if (!(this.flattened instanceof Array)) {
                     this.flattened = [this.flattened];
                 }
-                return this.toCSV();
+                return this.toCSV(true);
             } catch (err) {
                 throw new OperationError("Unable to parse JSON to CSV: " + err.toString());
             }
@@ -109,15 +110,17 @@ class JSONToCSV extends Operation {
      * Correctly escapes a cell's contents based on the cell and row delimiters.
      *
      * @param {string} data
+     * @param {boolean} force - Whether to force conversion of data to fit in a cell
      * @returns {string}
      */
-    escapeCellContents(data) {
+    escapeCellContents(data, force=false) {
         if (typeof data === "number") data = data.toString();
+        if (force && typeof data !== "string") data = JSON.stringify(data);
 
         // Double quotes should be doubled up
         data = data.replace(/"/g, '""');
 
-        // If the cell contains a cell or row delimiter or a double quote, it mut be enclosed in double quotes
+        // If the cell contains a cell or row delimiter or a double quote, it must be enclosed in double quotes
         if (
             data.indexOf(this.cellDelim) >= 0 ||
             data.indexOf(this.rowDelim) >= 0 ||

src/core/operations/ParseIPv6Address.mjs

@@ -165,6 +165,89 @@ class ParseIPv6Address extends Operation {
                 // Multicast
                 output += "\nThis is a reserved multicast address.";
                 output += "\nMulticast addresses range: ff00::/8";
+
+                switch (ipv6[0]) {
+                    case 0xff01:
+                        output += "\n\nReserved Multicast Block for Interface Local Scope";
+                        break;
+                    case 0xff02:
+                        output += "\n\nReserved Multicast Block for Link Local Scope";
+                        break;
+                    case 0xff03:
+                        output += "\n\nReserved Multicast Block for Realm Local Scope";
+                        break;
+                    case 0xff04:
+                        output += "\n\nReserved Multicast Block for Admin Local Scope";
+                        break;
+                    case 0xff05:
+                        output += "\n\nReserved Multicast Block for Site Local Scope";
+                        break;
+                    case 0xff08:
+                        output += "\n\nReserved Multicast Block for Organisation Local Scope";
+                        break;
+                    case 0xff0e:
+                        output += "\n\nReserved Multicast Block for Global Scope";
+                        break;
+                }
+
+                if (ipv6[6] === 1) {
+                    if (ipv6[7] === 2) {
+                        output += "\nReserved Multicast Address for 'All DHCP Servers and Relay Agents (defined in RFC3315)'";
+                    } else if (ipv6[7] === 3) {
+                        output += "\nReserved Multicast Address for 'All LLMNR Hosts (defined in RFC4795)'";
+                    }
+                } else {
+                    switch (ipv6[7]) {
+                        case 1:
+                            output += "\nReserved Multicast Address for 'All nodes'";
+                            break;
+                        case 2:
+                            output += "\nReserved Multicast Address for 'All routers'";
+                            break;
+                        case 5:
+                            output += "\nReserved Multicast Address for 'OSPFv3 - All OSPF routers'";
+                            break;
+                        case 6:
+                            output += "\nReserved Multicast Address for 'OSPFv3 - All Designated Routers'";
+                            break;
+                        case 8:
+                            output += "\nReserved Multicast Address for 'IS-IS for IPv6 Routers'";
+                            break;
+                        case 9:
+                            output += "\nReserved Multicast Address for 'RIP Routers'";
+                            break;
+                        case 0xa:
+                            output += "\nReserved Multicast Address for 'EIGRP Routers'";
+                            break;
+                        case 0xc:
+                            output += "\nReserved Multicast Address for 'Simple Service Discovery Protocol'";
+                            break;
+                        case 0xd:
+                            output += "\nReserved Multicast Address for 'PIM Routers'";
+                            break;
+                        case 0x16:
+                            output += "\nReserved Multicast Address for 'MLDv2 Reports (defined in RFC3810)'";
+                            break;
+                        case 0x6b:
+                            output += "\nReserved Multicast Address for 'Precision Time Protocol v2 Peer Delay Measurement Messages'";
+                            break;
+                        case 0xfb:
+                            output += "\nReserved Multicast Address for 'Multicast DNS'";
+                            break;
+                        case 0x101:
+                            output += "\nReserved Multicast Address for 'Network Time Protocol'";
+                            break;
+                        case 0x108:
+                            output += "\nReserved Multicast Address for 'Network Information Service'";
+                            break;
+                        case 0x114:
+                            output += "\nReserved Multicast Address for 'Experiments'";
+                            break;
+                        case 0x181:
+                            output += "\nReserved Multicast Address for 'Precision Time Protocol v2 Messages (exc. Peer Delay)'";
+                            break;
+                    }
+                }
             }
 
 

src/core/operations/RegularExpression.mjs

@@ -185,7 +185,7 @@ class RegularExpression extends Operation {
  * @param {boolean} captureGroups - Display each of the capture groups separately
  * @returns {string}
  */
-function regexList (input, regex, displayTotal, matches, captureGroups) {
+function regexList(input, regex, displayTotal, matches, captureGroups) {
     let output = "",
         total = 0,
         match;
@@ -225,7 +225,7 @@ function regexList (input, regex, displayTotal, matches, captureGroups) {
  * @param {boolean} displayTotal
  * @returns {string}
  */
-function regexHighlight (input, regex, displayTotal) {
+function regexHighlight(input, regex, displayTotal) {
     let output = "",
         title = "",
         hl = 1,

src/core/operations/ToHexdump.mjs

@@ -6,6 +6,7 @@
 
 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";
 
 /**
  * To Hexdump operation
@@ -28,7 +29,8 @@ class ToHexdump extends Operation {
             {
                 "name": "Width",
                 "type": "number",
-                "value": 16
+                "value": 16,
+                "min": 1
             },
             {
                 "name": "Upper case hex",
@@ -58,6 +60,9 @@ class ToHexdump extends Operation {
         const [length, upperCase, includeFinalLength, unixFormat] = args;
         const padding = 2;
 
+        if (length < 1 || Math.round(length) !== length)
+            throw new OperationError("Width must be a positive integer");
+
         let output = "";
         for (let i = 0; i < data.length; i += length) {
             const buff = data.slice(i, i+length);

src/web/App.mjs

@@ -725,7 +725,7 @@ class App {
         this.progress = 0;
         this.autoBake();
 
-        this.updateTitle(false, null, true);
+        this.updateTitle(true, null, true);
     }
 
 

src/web/html/index.html

@@ -686,7 +686,7 @@
                                 <div class="collapse" id="faq-load-files">
                                     <p>Yes! Just drag your file over the input box and drop it.</p>
                                     <p>CyberChef can handle files up to around 2GB (depending on your browser), however some of the operations may take a very long time to run over this much data.</p>
-                                    <p>If the output is larger than a certain threshold (default 1MiB), it will be presented to you as a file available for download. Slices of the file can be viewed in the output if you need to inspect them.</p>
+                                    <p>If the output is larger than a certain threshold (default <a href="#recipe=Multiply('Line%20feed')Convert_data_units('Bytes%20(B)','Mebibytes%20(MiB)')&input=MTAyNAoxMDI0">1MiB</a>), it will be presented to you as a file available for download. Slices of the file can be viewed in the output if you need to inspect them.</p>
                                 </div>
                                 <br>
 

src/web/waiters/ControlsWaiter.mjs

@@ -100,7 +100,7 @@ class ControlsWaiter {
         const includeRecipe = document.getElementById("save-link-recipe-checkbox").checked;
         const includeInput = document.getElementById("save-link-input-checkbox").checked;
         const saveLinkEl = document.getElementById("save-link");
-        const saveLink = this.generateStateUrl(includeRecipe, includeInput, recipeConfig);
+        const saveLink = this.generateStateUrl(includeRecipe, includeInput, null, recipeConfig);
 
         saveLinkEl.innerHTML = Utils.escapeHtml(Utils.truncate(saveLink, 120));
         saveLinkEl.setAttribute("href", saveLink);
@@ -128,11 +128,13 @@ class ControlsWaiter {
         includeRecipe = includeRecipe && (recipeConfig.length > 0);
 
         // If we don't get passed an input, get it from the current URI
-        if (input === null) {
+        if (input === null && includeInput) {
             const params = this.app.getURIParams();
             if (params.input) {
                 includeInput = true;
                 input = params.input;
+            } else {
+                includeInput = false;
             }
         }
 

src/web/waiters/OperationsWaiter.mjs

@@ -6,7 +6,7 @@
 
 import HTMLOperation from "../HTMLOperation.mjs";
 import Sortable from "sortablejs";
-import {fuzzyMatch, calcMatchRanges} from "../../core/lib/FuzzySearch.mjs";
+import {fuzzyMatch, calcMatchRanges} from "../../core/lib/FuzzyMatch.mjs";
 
 
 /**

tests/operations/index.mjs

@@ -102,6 +102,10 @@ import "./tests/Colossus.mjs";
 import "./tests/ParseObjectIDTimestamp.mjs";
 import "./tests/Unicode.mjs";
 import "./tests/RSA.mjs";
+import "./tests/CBOREncode.mjs";
+import "./tests/CBORDecode.mjs";
+import "./tests/JA3Fingerprint.mjs";
+
 
 // Cannot test operations that use the File type yet
 // import "./tests/SplitColourChannels.mjs";

tests/operations/tests/CBORDecode.mjs

@@ -0,0 +1,144 @@
+/**
+ * CBOR Decode Tests
+ *
+ * @author Danh4 [dan.h4@ncsc.gov.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "CBOR Decode: Can decode integer",
+        input: "0f",
+        expectedOutput: "15",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Decode: Can decode decimal",
+        input: "f9 3e 00",
+        expectedOutput: "1.5",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can decode text",
+        input: "64 54 65 78 74",
+        expectedOutput: "\"Text\"",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can decode boolean true",
+        input: "f5",
+        expectedOutput: "true",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can decode boolean false",
+        input: "f4",
+        expectedOutput: "false",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can decode map",
+        input: "a3 61 61 01 61 62 02 61 63 03",
+        expectedOutput: JSON.stringify({a: 1, b: 2, c: 3}),
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            },
+            {
+                op: "JSON Minify",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can decode list",
+        input: "83 00 01 02",
+        expectedOutput: "[0,1,2]",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            },
+            {
+                op: "JSON Minify",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "From Hex: Can round trip with encode",
+        input: JSON.stringify({a: 1, b: false, c: [1, 2, 3]}),
+        expectedOutput: JSON.stringify({a: 1, b: false, c: [1, 2, 3]}),
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "CBOR Decode",
+                args: []
+            },
+            {
+                op: "JSON Minify",
+                args: []
+            }
+        ]
+    }
+]);

tests/operations/tests/CBOREncode.mjs

@@ -0,0 +1,117 @@
+/**
+ * CBOR Encode Tests.
+ *
+ * @author Danh4 [dan.h4@ncsc.gov.uk]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "CBOR Encode: Can encode integer",
+        input: "15",
+        expectedOutput: "0f",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Decode: Can encode decimal",
+        input: "1.5",
+        expectedOutput: "f9 3e 00",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Encode: Can encode text",
+        input: "\"Text\"",
+        expectedOutput: "64 54 65 78 74",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Encode: Can encode boolean true",
+        input: "true",
+        expectedOutput: "f5",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Encode: Can encode boolean false",
+        input: "false",
+        expectedOutput: "f4",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Encode: Can encode map",
+        input: JSON.stringify({a: 1, b: 2, c: 3}),
+        expectedOutput: "a3 61 61 01 61 62 02 61 63 03",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    },
+    {
+        name: "CBOR Encode: Can encode list",
+        input: "[0,1,2]",
+        expectedOutput: "83 00 01 02",
+        recipeConfig: [
+            {
+                op: "CBOR Encode",
+                args: []
+            },
+            {
+                op: "To Hex",
+                args: []
+            }
+        ]
+    }
+]);

tests/operations/tests/Crypt.mjs

@@ -73,7 +73,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""},
-                    "CBC", "Raw", "Hex"
+                    "CBC", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -88,7 +89,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00000000000000000000000000000000"},
-                    "CBC", "Raw", "Hex"
+                    "CBC", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -103,7 +105,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00000000000000000000000000000000"},
-                    "CTR", "Raw", "Hex"
+                    "CTR", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -118,7 +121,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
-                    "CBC", "Raw", "Hex"
+                    "CBC", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -133,7 +137,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
-                    "CFB", "Raw", "Hex"
+                    "CFB", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -148,7 +153,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
-                    "OFB", "Raw", "Hex"
+                    "OFB", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -163,7 +169,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
-                    "CTR", "Raw", "Hex"
+                    "CTR", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -178,7 +185,8 @@ The following algorithms will be used based on the size of the key:
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": ""},
-                    "ECB", "Raw", "Hex"
+                    "ECB", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -195,7 +203,8 @@ Tag: 16a3e732a605cc9ca29108f742ca0743`,
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": ""},
-                    "GCM", "Raw", "Hex", ""
+                    "GCM", "Raw", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -212,7 +221,8 @@ Tag: 3b5378917f67b0aade9891fc6c291646`,
                 "args": [
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "ffeeddccbbaa99887766554433221100"},
-                    "GCM", "Raw", "Hex", "additional data"
+                    "GCM", "Raw", "Hex",
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -227,7 +237,8 @@ Tag: 3b5378917f67b0aade9891fc6c291646`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CBC", "Hex", "Hex"
+                    "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -242,7 +253,8 @@ Tag: 3b5378917f67b0aade9891fc6c291646`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CFB", "Hex", "Hex"
+                    "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -257,7 +269,8 @@ Tag: 3b5378917f67b0aade9891fc6c291646`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "OFB", "Hex", "Hex"
+                    "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -272,7 +285,8 @@ Tag: 3b5378917f67b0aade9891fc6c291646`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CTR", "Hex", "Hex"
+                    "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -289,7 +303,8 @@ Tag: 70fad2ca19412c20f40fd06918736e56`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", ""
+                    "GCM", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -306,7 +321,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", "additional data"
+                    "GCM", "Hex", "Hex",
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -321,7 +337,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "ECB", "Hex", "Hex"
+                    "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -336,7 +353,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CBC", "Hex", "Hex"
+                    "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -351,7 +369,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CFB", "Hex", "Hex"
+                    "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -366,7 +385,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "OFB", "Hex", "Hex"
+                    "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -381,7 +401,8 @@ Tag: 61cc4b70809452b0b3e38f913fa0a109`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CTR", "Hex", "Hex"
+                    "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -398,7 +419,8 @@ Tag: 86db597d5302595223cadbd990f1309b`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", ""
+                    "GCM", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -415,7 +437,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", "additional data"
+                    "GCM", "Hex", "Hex",
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -430,7 +453,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "ECB", "Hex", "Hex"
+                    "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -445,7 +469,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CBC", "Hex", "Hex"
+                    "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -460,7 +485,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CFB", "Hex", "Hex"
+                    "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -475,7 +501,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "OFB", "Hex", "Hex"
+                    "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -490,7 +517,8 @@ Tag: aeedf3e6ca4201577c0cf3e9ce58159d`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "CTR", "Hex", "Hex"
+                    "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -507,7 +535,8 @@ Tag: 821b1e5f32dad052e502775a523d957a`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", ""
+                    "GCM", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -524,7 +553,8 @@ Tag: a8f04c4d93bbef82bef61a103371aef9`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "GCM", "Hex", "Hex", "additional data"
+                    "GCM", "Hex", "Hex",
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -539,7 +569,8 @@ Tag: a8f04c4d93bbef82bef61a103371aef9`,
                 "args": [
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
-                    "ECB", "Hex", "Hex"
+                    "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -748,6 +779,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""},
                     "CBC", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -764,6 +796,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00000000000000000000000000000000"},
                     "CBC", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -780,6 +813,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00000000000000000000000000000000"},
                     "CTR", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -796,6 +830,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     "CBC", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -812,6 +847,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     "CFB", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -828,6 +864,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     "OFB", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -844,6 +881,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     "CTR", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -860,6 +898,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "00112233445566778899aabbccddeeff"},
                     {"option": "Hex", "string": ""},
                     "ECB", "Hex", "Raw",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -877,7 +916,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": ""},
                     "GCM", "Hex", "Raw",
                     {"option": "Hex", "string": "16a3e732a605cc9ca29108f742ca0743"},
-                    ""
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -894,7 +933,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "ffeeddccbbaa99887766554433221100"},
                     "GCM", "Hex", "Raw",
                     {"option": "Hex", "string": "3b5378917f67b0aade9891fc6c291646"},
-                    "additional data"
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -910,6 +949,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -926,6 +966,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -942,6 +983,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -958,6 +1000,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -975,7 +1018,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "70fad2ca19412c20f40fd06918736e56"},
-                    ""
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -992,7 +1035,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "61cc4b70809452b0b3e38f913fa0a109"},
-                    "additional data"
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -1008,6 +1051,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "51e201d463698ef5f717f71f5b4712af"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1024,6 +1068,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1040,6 +1085,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1056,6 +1102,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1072,6 +1119,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1089,7 +1137,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "86db597d5302595223cadbd990f1309b"},
-                    ""
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -1106,7 +1154,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "aeedf3e6ca4201577c0cf3e9ce58159d"},
-                    "additional data"
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -1122,6 +1170,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "6801ed503c9d96ee5f9d78b07ab1b295dba3c2adf81c7816"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1138,6 +1187,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CBC", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1154,6 +1204,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1170,6 +1221,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "OFB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1186,6 +1238,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "CTR", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }
@@ -1203,7 +1256,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "821b1e5f32dad052e502775a523d957a"},
-                    ""
+                    {"option": "Hex", "string": ""}
                 ]
             }
         ],
@@ -1220,7 +1273,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "GCM", "Hex", "Hex",
                     {"option": "Hex", "string": "a8f04c4d93bbef82bef61a103371aef9"},
-                    "additional data"
+                    {"option": "UTF8", "string": "additional data"}
                 ]
             }
         ],
@@ -1236,6 +1289,7 @@ The following algorithms will be used based on the size of the key:
                     {"option": "Hex", "string": "2d767f6e9333d1c77581946e160b2b7368c2cdd5e2b80f04ca09d64e02afbfe1"},
                     {"option": "Hex", "string": "1748e7179bd56570d51fa4ba287cc3e5"},
                     "ECB", "Hex", "Hex",
+                    {"option": "Hex", "string": ""},
                     {"option": "Hex", "string": ""}
                 ]
             }

tests/operations/tests/JA3Fingerprint.mjs

@@ -0,0 +1,55 @@
+/**
+ * JA3Fingerprint tests.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "JA3 Fingerprint: TLS 1.0",
+        input: "16030100a4010000a00301543dd2dd48f517ca9a93b1e599f019fdece704a23e86c1dcac588427abbaddf200005cc014c00a0039003800880087c00fc00500350084c012c00800160013c00dc003000ac013c00900330032009a009900450044c00ec004002f009600410007c011c007c00cc002000500040015001200090014001100080006000300ff0100001b000b000403000102000a000600040018001700230000000f000101",
+        expectedOutput: "503053a0c5b2bd9b9334bf7f3d3b8852",
+        recipeConfig: [
+            {
+                "op": "JA3 Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3 Fingerprint: TLS 1.1",
+        input: "16030100a4010000a00302543dd2ed907e47d0086f34bee2c52dd6ccd8de63ba9387f5e810b09d9d49b38000005cc014c00a0039003800880087c00fc00500350084c012c00800160013c00dc003000ac013c00900330032009a009900450044c00ec004002f009600410007c011c007c00cc002000500040015001200090014001100080006000300ff0100001b000b000403000102000a000600040018001700230000000f000101",
+        expectedOutput: "a314eb64cee6cb832aaaa372c8295bab",
+        recipeConfig: [
+            {
+                "op": "JA3 Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3 Fingerprint: TLS 1.2",
+        input: "1603010102010000fe0303543dd3283283692d85f9416b5ccc65d2aafca45c6530b3c6eafbf6d371b6a015000094c030c02cc028c024c014c00a00a3009f006b006a0039003800880087c032c02ec02ac026c00fc005009d003d00350084c012c00800160013c00dc003000ac02fc02bc027c023c013c00900a2009e0067004000330032009a009900450044c031c02dc029c025c00ec004009c003c002f009600410007c011c007c00cc002000500040015001200090014001100080006000300ff01000041000b000403000102000a000600040018001700230000000d002200200601060206030501050205030401040204030301030203030201020202030101000f000101",
+        expectedOutput: "c1a36e1a870786cc75edddc0009eaf3a",
+        recipeConfig: [
+            {
+                "op": "JA3 Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3 Fingerprint: TLS 1.3",
+        input: "1603010200010001fc03034355d402c132771a9386b6e9994ae37069e0621af504c26673b1343843c21d8d0000264a4a130113021303c02bc02fc02cc030cca9cca8cc14cc13c013c014009c009d002f0035000a010001addada0000ff01000100000000180016000013626c6f672e636c6f7564666c6172652e636f6d0017000000230000000d00140012040308040401050308050501080606010201000500050100000000001200000010000e000c02683208687474702f312e3175500000000b000201000028002b00295a5a000100001d0020cf78b9167af054b922a96752b43973107b2a57766357dd288b2b42ab5df30e08002d00020101002b000b0acaca7f12030303020301000a000a00085a5a001d001700180a0a000100001500e4000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "4826a90ec2daf4f7b4b64cc1c8bd343b",
+        recipeConfig: [
+            {
+                "op": "JA3 Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+]);

tests/operations/tests/JA3SFingerprint.mjs

@@ -0,0 +1,55 @@
+/**
+ * JA3SFingerprint tests.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "JA3S Fingerprint: TLS 1.0",
+        input: "160301003d020000390301543dd2ddedbfe33895bd6bc676a3fa6b9fe5773a6e04d5476d1af3bcbc1dcbbb00c011000011ff01000100000b00040300010200230000",
+        expectedOutput: "bed95e1b525d2f41db3a6d68fac5b566",
+        recipeConfig: [
+            {
+                "op": "JA3S Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3S Fingerprint: TLS 1.1",
+        input: "160302003d020000390302543dd2ed88131999a0120d36c14a4139671d75aae3d7d7779081d3cf7dd7725a00c013000011ff01000100000b00040300010200230000",
+        expectedOutput: "130fac2dc19b142500acb0abc63b6379",
+        recipeConfig: [
+            {
+                "op": "JA3S Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3S Fingerprint: TLS 1.2",
+        input: "160303003d020000390303543dd328b38b445686739d58fab733fa23838f575e0e5ad9a1b9baace6cc3b4100c02f000011ff01000100000b00040300010200230000",
+        expectedOutput: "ccc514751b175866924439bdbb5bba34",
+        recipeConfig: [
+            {
+                "op": "JA3S Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "JA3S Fingerprint: TLS 1.3",
+        input: "16030100520200004e7f123ef1609fd3f4fa8668aac5822d500fb0639b22671d0fb7258597355795511bf61301002800280024001d0020ae0e282a3b7a463e71064ecbaf671586e979b0edbebf7a4735c31678c70f660c",
+        expectedOutput: "986ae432c402479fe7a0c6fbe02164c1",
+        recipeConfig: [
+            {
+                "op": "JA3S Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+]);

tests/operations/tests/Register.mjs

@@ -64,7 +64,10 @@ TestRegister.addTests([
                         "option": "Hex",
                         "string": ""
                     },
-                    ""
+                    {
+                        "option": "Hex",
+                        "string": ""
+                    }
                 ]
             }
         ]