9.33.0

Updated CHANGELOG
Improve CJS and ESM module support #1037
2025-12-27 13:43:30 +00:00 · 2022-03-28 10:58:30 +01:00 · 2022-03-28 10:58:25 +01:00 · 2022-03-28 10:52:28 +01:00 · 2022-03-25 18:33:22 +00:00 · 2022-03-25 18:28:01 +00:00
64 changed files with 24084 additions and 4752 deletions
--- a/.eslintrc.json
+++ b/.eslintrc.json
@@ -1,5 +1,5 @@
 {
-    "parser": "babel-eslint",
+    "parser": "@babel/eslint-parser",
    "parserOptions": {
        "ecmaVersion": 9,
        "ecmaFeatures": {
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -1,6 +1,7 @@
 name: "CodeQL Analysis"

 on:
+  workflow_dispatch:
  push:
    branches: [ master ]
  pull_request:
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -1,6 +1,7 @@
 name: "Master Build, Test & Deploy"

 on:
+  workflow_dispatch:
  push:
    branches:
    - master
@@ -14,7 +15,7 @@ jobs:
    - name: Set node version
      uses: actions/setup-node@v1
      with:
-        node-version: '10.x'
+        node-version: '17.x'

    - name: Install
      run: |
@@ -36,9 +37,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()
--- a/.github/workflows/pull_requests.yml
+++ b/.github/workflows/pull_requests.yml
@@ -1,6 +1,7 @@
 name: "Pull Requests"

 on:
+  workflow_dispatch:
  pull_request:
    types: [synchronize, opened, reopened]

@@ -13,7 +14,7 @@ jobs:
    - name: Set node version
      uses: actions/setup-node@v1
      with:
-        node-version: '10.x'
+        node-version: '17.x'

    - name: Install
      run: |
@@ -32,6 +33,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
--- a/.github/workflows/releases.yml
+++ b/.github/workflows/releases.yml
@@ -1,6 +1,7 @@
 name: "Releases"

 on:
+  workflow_dispatch:
  push:
    tags:
    - 'v*'
@@ -14,7 +15,7 @@ jobs:
    - name: Set node version
      uses: actions/setup-node@v1
      with:
-        node-version: '10.x'
+        node-version: '17.x'

    - name: Install
      run: |
@@ -33,9 +34,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()
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-lts/dubnium
+17
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,25 @@ All major and minor version changes will be documented in this file. Details of

 ## Details

+### [9.33.0] - 2022-03-25
+- Updated to support Node 17 [@n1474335] [@john19696] [@t-8ch] | [[#1326] [#1313] [#1244]
+- Improved CJS and ESM module support [@d98762625] | [#1037]
+
+### [9.32.0] - 2021-08-18
+- 'Protobuf Encode' operation added and decode operation modified to allow decoding with full and partial schemas [@n1474335] | [dd18e52]
+
+### [9.31.0] - 2021-08-10
+- 'HASSH Client Fingerprint' and 'HASSH Server Fingerprint' operations added [@n1474335] | [e9ca4dc]
+
+### [9.30.0] - 2021-08-10
+- 'JA3S Fingerprint' operation added [@n1474335] | [289a417]
+
+### [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]

@@ -256,6 +275,12 @@ All major and minor version changes will be documented in this file. Details of



+[9.33.0]: https://github.com/gchq/CyberChef/releases/tag/v9.33.0
+[9.32.0]: https://github.com/gchq/CyberChef/releases/tag/v9.32.0
+[9.31.0]: https://github.com/gchq/CyberChef/releases/tag/v9.31.0
+[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
@@ -363,8 +388,15 @@ 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
+[@john19696]: https://github.com/john19696
+[@t-8ch]: https://github.com/t-8ch

 [8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7
+[9a33498]: https://github.com/gchq/CyberChef/commit/9a33498fed26a8df9c9f35f39a78a174bf50a513
+[289a417]: https://github.com/gchq/CyberChef/commit/289a417dfb5923de5e1694354ec42a08d9395bfe
+[e9ca4dc]: https://github.com/gchq/CyberChef/commit/e9ca4dc9caf98f33fd986431cd400c88082a42b8
+[dd18e52]: https://github.com/gchq/CyberChef/commit/dd18e529939078b89867297b181a584e8b2cc7da

 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -438,8 +470,13 @@ 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
+[#1037]: https://github.com/gchq/CyberChef/pull/1037
 [#1045]: https://github.com/gchq/CyberChef/pull/1045
 [#1049]: https://github.com/gchq/CyberChef/pull/1049
-[#1083]: https://github.com/gchq/CyberChef/pull/1083
+[#1083]: https://github.com/gchq/CyberChef/pull/1083
+[#1244]: https://github.com/gchq/CyberChef/pull/1244
+[#1313]: https://github.com/gchq/CyberChef/pull/1313
+[#1326]: https://github.com/gchq/CyberChef/pull/1326
--- a/Gruntfile.js
+++ b/Gruntfile.js
@@ -6,6 +6,8 @@ const BundleAnalyzerPlugin = require("webpack-bundle-analyzer").BundleAnalyzerPl
 const glob = require("glob");
 const path = require("path");

+const nodeFlags = "--experimental-modules --experimental-json-modules --experimental-specifier-resolution=node --no-warnings --no-deprecation";
+
 /**
 * Grunt configuration for building the app in various formats.
 *
@@ -48,7 +50,7 @@ module.exports = function (grunt) {

    grunt.registerTask("testnodeconsumer",
        "A task which checks whether consuming CJS and ESM apps work with the CyberChef build",
-        ["exec:setupNodeConsumers", "exec:testCJSNodeConsumer", "exec:testESMNodeConsumer", "exec:testESMDeepImportNodeConsumer", "exec:teardownNodeConsumers"]);
+        ["exec:setupNodeConsumers", "exec:testCJSNodeConsumer", "exec:testESMNodeConsumer", "exec:teardownNodeConsumers"]);

    grunt.registerTask("default",
        "Lints the code base",
@@ -187,9 +189,6 @@ module.exports = function (grunt) {
            standalone: ["build/prod/CyberChef*.html"]
        },
        eslint: {
-            options: {
-                configFile: "./.eslintrc.json"
-            },
            configs: ["*.{js,mjs}"],
            core: ["src/core/**/*.{js,mjs}", "!src/core/vendor/**/*", "!src/core/operations/legacy/**/*"],
            web: ["src/web/**/*.{js,mjs}", "!src/web/static/**/*"],
@@ -349,15 +348,15 @@ module.exports = function (grunt) {
                command: "git gc --prune=now --aggressive"
            },
            sitemap: {
-                command: "node --experimental-modules --no-warnings --no-deprecation src/web/static/sitemap.mjs > build/prod/sitemap.xml",
+                command: `node ${nodeFlags} src/web/static/sitemap.mjs > build/prod/sitemap.xml`,
                sync: true
            },
            generateConfig: {
                command: chainCommands([
                    "echo '\n--- Regenerating config files. ---'",
                    "echo [] > src/core/config/OperationConfig.json",
-                    "node --experimental-modules --no-warnings --no-deprecation src/core/config/scripts/generateOpsIndex.mjs",
-                    "node --experimental-modules --no-warnings --no-deprecation src/core/config/scripts/generateConfig.mjs",
+                    `node ${nodeFlags} src/core/config/scripts/generateOpsIndex.mjs`,
+                    `node ${nodeFlags} src/core/config/scripts/generateConfig.mjs`,
                    "echo '--- Config scripts finished. ---\n'"
                ]),
                sync: true
@@ -365,7 +364,7 @@ module.exports = function (grunt) {
            generateNodeIndex: {
                command: chainCommands([
                    "echo '\n--- Regenerating node index ---'",
-                    "node --experimental-modules --no-warnings --no-deprecation src/node/config/scripts/generateNodeIndex.mjs",
+                    `node ${nodeFlags} src/node/config/scripts/generateNodeIndex.mjs`,
                    "echo '--- Node index generated. ---\n'"
                ]),
                sync: true
@@ -393,21 +392,14 @@ module.exports = function (grunt) {
            testCJSNodeConsumer: {
                command: chainCommands([
                    `cd ${nodeConsumerTestPath}`,
-                    "node --no-warnings cjs-consumer.js",
+                    `node ${nodeFlags} cjs-consumer.js`,
                ]),
                stdout: false,
            },
            testESMNodeConsumer: {
                command: chainCommands([
                    `cd ${nodeConsumerTestPath}`,
-                    "node --no-warnings --experimental-modules esm-consumer.mjs",
-                ]),
-                stdout: false,
-            },
-            testESMDeepImportNodeConsumer: {
-                command: chainCommands([
-                    `cd ${nodeConsumerTestPath}`,
-                    "node --no-warnings --experimental-modules esm-deep-import-consumer.mjs",
+                    `node ${nodeFlags} esm-consumer.mjs`,
                ]),
                stdout: false,
            },
--- a/babel.config.js
+++ b/babel.config.js
@@ -11,6 +11,7 @@ module.exports = function(api) {
        ],
        "plugins": [
            "dynamic-import-node",
+            "@babel/plugin-syntax-import-assertions",
            [
                "babel-plugin-transform-builtin-extend", {
                    "globals": ["Error"]
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "cyberchef",
-  "version": "9.27.0",
+  "version": "9.33.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",
@@ -27,117 +27,121 @@
    "type": "git",
    "url": "https://github.com/gchq/CyberChef/"
  },
-  "main": "src/node/cjs.js",
-  "module": "src/node/index.mjs",
+  "main": "src/node/wrapper.js",
+  "exports": {
+    "import": "./src/node/index.mjs",
+    "require": "./src/node/wrapper.js"
+  },
  "bugs": "https://github.com/gchq/CyberChef/issues",
  "browserslist": [
    "Chrome >= 50",
    "Firefox >= 38",
-    "node >= 10"
+    "node >= 16"
  ],
  "devDependencies": {
-    "@babel/core": "^7.12.16",
-    "@babel/plugin-transform-runtime": "^7.12.15",
-    "@babel/preset-env": "^7.12.16",
-    "autoprefixer": "^10.2.4",
-    "babel-eslint": "^10.1.0",
-    "babel-loader": "^8.2.2",
+    "@babel/core": "^7.17.8",
+    "@babel/eslint-parser": "^7.17.0",
+    "@babel/plugin-syntax-import-assertions": "^7.16.7",
+    "@babel/plugin-transform-runtime": "^7.17.0",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/runtime": "^7.17.8",
+    "autoprefixer": "^10.3.1",
+    "babel-loader": "^8.2.4",
    "babel-plugin-dynamic-import-node": "^2.3.3",
-    "chromedriver": "^88.0.0",
+    "chromedriver": "^99.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",
-    "exports-loader": "^2.0.0",
+    "copy-webpack-plugin": "^9.0.1",
+    "core-js": "^3.21.1",
+    "css-loader": "5.2.7",
+    "eslint": "^8.11.0",
+    "exports-loader": "^3.0.0",
    "file-loader": "^6.2.0",
-    "grunt": "^1.3.0",
+    "grunt": "^1.4.1",
    "grunt-chmod": "~1.1.1",
    "grunt-concurrent": "^3.0.0",
    "grunt-contrib-clean": "~2.0.0",
    "grunt-contrib-connect": "^3.0.0",
    "grunt-contrib-copy": "~1.0.0",
    "grunt-contrib-watch": "^1.1.0",
-    "grunt-eslint": "^23.0.0",
+    "grunt-eslint": "^24.0.0",
    "grunt-exec": "~3.0.0",
-    "grunt-webpack": "^4.0.2",
+    "grunt-webpack": "^4.0.3",
    "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",
-    "node-sass": "^5.0.0",
-    "postcss": "^8.2.6",
-    "postcss-css-variables": "^0.17.0",
-    "postcss-import": "^14.0.0",
-    "postcss-loader": "^5.0.0",
+    "html-webpack-plugin": "^5.3.2",
+    "imports-loader": "^3.0.0",
+    "mini-css-extract-plugin": "1.3.7",
+    "nightwatch": "^1.7.8",
+    "postcss": "^8.3.6",
+    "postcss-css-variables": "^0.18.0",
+    "postcss-import": "^14.0.2",
+    "postcss-loader": "^6.1.1",
    "prompt": "^1.1.0",
-    "sass-loader": "^11.0.1",
-    "sitemap": "^6.3.6",
-    "style-loader": "^2.0.0",
+    "sass-loader": "^12.1.0",
+    "sitemap": "^7.0.0",
+    "style-loader": "^3.2.1",
    "svg-url-loader": "^7.1.1",
    "url-loader": "^4.1.1",
-    "webpack": "^5.21.2",
-    "webpack-bundle-analyzer": "^4.4.0",
-    "webpack-dev-server": "^3.11.2",
-    "webpack-node-externals": "^2.5.2",
+    "webpack": "^5.70.0",
+    "webpack-bundle-analyzer": "^4.4.2",
+    "webpack-dev-server": "3.11.2",
+    "webpack-node-externals": "^3.0.0",
    "worker-loader": "^3.0.8"
  },
  "dependencies": {
    "@babel/polyfill": "^7.12.1",
-    "@babel/runtime": "^7.12.13",
    "arrive": "^2.4.1",
-    "avsc": "^5.5.3",
+    "avsc": "^5.7.3",
    "babel-plugin-transform-builtin-extend": "1.1.2",
    "bcryptjs": "^2.4.3",
    "bignumber.js": "^9.0.1",
-    "blakejs": "^1.1.0",
+    "blakejs": "^1.1.1",
    "bootstrap": "4.6.0",
-    "bootstrap-colorpicker": "^3.2.0",
+    "bootstrap-colorpicker": "^3.4.0",
    "bootstrap-material-design": "^4.1.3",
    "browserify-zlib": "^0.2.0",
-    "bson": "^4.2.2",
+    "bson": "^4.4.1",
    "buffer": "^6.0.3",
+    "cbor": "5.0.1",
    "chi-squared": "^1.1.0",
-    "codepage": "^1.14.0",
-    "core-js": "^3.8.3",
+    "codepage": "^1.15.0",
    "crypto-api": "^0.8.5",
    "crypto-browserify": "^3.12.0",
-    "crypto-js": "^4.0.0",
+    "crypto-js": "^4.1.1",
    "ctph.js": "0.0.5",
-    "d3": "^6.5.0",
+    "d3": "6.5.0",
    "d3-hexbin": "^0.2.2",
    "diff": "^5.0.0",
-    "es6-promisify": "^6.1.1",
+    "es6-promisify": "^7.0.0",
    "escodegen": "^2.0.0",
-    "esm": "^3.2.25",
    "esprima": "^4.0.1",
    "exif-parser": "^0.1.12",
    "file-saver": "^2.0.5",
    "flat": "^5.0.2",
    "geodesy": "1.1.3",
-    "highlight.js": "^10.6.0",
+    "highlight.js": "^11.2.0",
    "jimp": "^0.16.1",
-    "jquery": "3.5.1",
+    "jquery": "3.6.0",
    "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",
+    "jsqr": "^1.4.0",
+    "jsrsasign": "^10.4.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",
+    "markdown-it": "^12.3.2",
    "moment": "^2.29.1",
    "moment-timezone": "^0.5.33",
    "ngeohash": "^0.6.3",
    "node-forge": "^0.10.0",
    "node-md6": "^0.1.0",
+    "node-sass": "^7.0.1",
    "nodom": "^2.4.0",
    "notepack.io": "^2.3.0",
    "nwmatcher": "^1.4.4",
@@ -145,35 +149,36 @@
    "path": "^0.12.7",
    "popper.js": "^1.16.1",
    "process": "^0.11.10",
+    "protobufjs": "^6.11.2",
    "qr-image": "^3.2.0",
    "scryptsy": "^2.1.0",
    "snackbarjs": "^1.1.0",
-    "sortablejs": "^1.13.0",
-    "split.js": "^1.6.2",
-    "ssdeep.js": "0.0.2",
+    "sortablejs": "^1.14.0",
+    "split.js": "^1.6.4",
+    "ssdeep.js": "0.0.3",
    "stream-browserify": "^3.0.0",
-    "terser": "^5.5.1",
-    "tesseract.js": "2.1.1",
-    "ua-parser-js": "^0.7.24",
+    "terser": "^5.7.1",
+    "tesseract.js": "2.1.5",
+    "ua-parser-js": "^0.7.28",
    "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",
+    "xregexp": "^5.1.0",
    "zlibjs": "^0.3.1"
  },
  "scripts": {
    "start": "npx grunt dev",
    "build": "npx grunt prod",
-    "repl": "node src/node/repl.js",
-    "test": "npx grunt configTests && node --experimental-modules --no-warnings --no-deprecation tests/node/index.mjs && node --experimental-modules --no-warnings --no-deprecation tests/operations/index.mjs",
+    "repl": "node --experimental-modules --experimental-json-modules --experimental-specifier-resolution=node --no-warnings src/node/repl.mjs",
+    "test": "npx grunt configTests && node --experimental-modules --experimental-json-modules --no-warnings --no-deprecation tests/node/index.mjs && node --experimental-modules --experimental-json-modules --no-warnings --no-deprecation tests/operations/index.mjs",
    "test-node-consumer": "npx grunt testnodeconsumer",
    "testui": "npx grunt testui",
    "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 --experimental-json-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"
  }
--- a/src/core/ChefWorker.js
+++ b/src/core/ChefWorker.js
@@ -7,7 +7,7 @@
 */

 import Chef from "./Chef.mjs";
-import OperationConfig from "./config/OperationConfig.json";
+import OperationConfig from "./config/OperationConfig.json" assert {type: "json"};
 import OpModules from "./config/modules/OpModules.mjs";

 // Add ">" to the start of all log messages in the Chef Worker
--- a/src/core/Recipe.mjs
+++ b/src/core/Recipe.mjs
@@ -4,7 +4,7 @@
 * @license Apache-2.0
 */

-import OperationConfig from "./config/OperationConfig.json";
+import OperationConfig from "./config/OperationConfig.json" assert {type: "json"};
 import OperationError from "./errors/OperationError.mjs";
 import Operation from "./Operation.mjs";
 import DishError from "./errors/DishError.mjs";
--- a/src/core/Utils.mjs
+++ b/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
--- a/src/core/config/Categories.json
+++ b/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"
        ]
    },
    {
@@ -189,8 +191,13 @@
            "URL Encode",
            "URL Decode",
            "Protobuf Decode",
+            "Protobuf Encode",
            "VarInt Encode",
            "VarInt Decode",
+            "JA3 Fingerprint",
+            "JA3S Fingerprint",
+            "HASSH Client Fingerprint",
+            "HASSH Server Fingerprint",
            "Format MAC addresses",
            "Change IP format",
            "Group IP addresses",
--- a/src/core/errors/index.mjs
+++ b/src/core/errors/index.mjs
@@ -1,6 +1,6 @@
 import OperationError from "./OperationError.mjs";
 import DishError from "./DishError.mjs";
-import ExcludedOperationError from "./ExcludedOperationError";
+import ExcludedOperationError from "./ExcludedOperationError.mjs";

 export {
    OperationError,
--- a/src/core/lib/Binary.mjs
+++ b/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, "");

--- a/src/core/lib/BitwiseOp.mjs
+++ b/src/core/lib/BitwiseOp.mjs
@@ -34,10 +34,10 @@ export function bitOp (input, key, func, nullPreserving, scheme) {
            !(nullPreserving && (o === 0 || o === k))) {
            switch (scheme) {
                case "Input differential":
-                    key[i % key.length] = x;
+                    key[i % key.length] = o;
                    break;
                case "Output differential":
-                    key[i % key.length] = o;
+                    key[i % key.length] = x;
                    break;
            }
        }
--- a/src/core/lib/Hex.mjs
+++ b/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, "");
--- a/src/core/lib/Magic.mjs
+++ b/src/core/lib/Magic.mjs
@@ -1,4 +1,4 @@
-import OperationConfig from "../config/OperationConfig.json";
+import OperationConfig from "../config/OperationConfig.json" assert {type: "json"};
 import Utils, { isWorkerEnvironment } from "../Utils.mjs";
 import Recipe from "../Recipe.mjs";
 import Dish from "../Dish.mjs";
--- a/src/core/lib/Protobuf.mjs
+++ b/src/core/lib/Protobuf.mjs
@@ -1,4 +1,5 @@
 import Utils from "../Utils.mjs";
+import protobuf from "protobufjs";

 /**
 * Protobuf lib. Contains functions to decode protobuf serialised
@@ -32,9 +33,10 @@ class Protobuf {
        this.MSB = 0x80;
        this.VALUE = 0x7f;

-        // Declare offset and length
+        // Declare offset, length, and field type object
        this.offset = 0;
        this.LENGTH = data.length;
+        this.fieldTypes = {};
    }

    // Public Functions
@@ -76,15 +78,281 @@ class Protobuf {
        return pb._varInt();
    }

+    /**
+     * Encode input JSON according to the given schema
+     *
+     * @param {Object} input
+     * @param {Object []} args
+     * @returns {Object}
+     */
+    static encode(input, args) {
+        this.updateProtoRoot(args[0]);
+        if (!this.mainMessageName) {
+            throw new Error("Schema Error: Schema not defined");
+        }
+        const message = this.parsedProto.root.nested[this.mainMessageName];
+
+        // Convert input into instance of message, and verify instance
+        input = message.fromObject(input);
+        const error = message.verify(input);
+        if (error) {
+            throw new Error("Input Error: " + error);
+        }
+        // Encode input
+        const output = message.encode(input).finish();
+        return new Uint8Array(output).buffer;
+    }
+
    /**
     * Parse Protobuf data
     *
     * @param {byteArray} input
     * @returns {Object}
     */
-    static decode(input) {
+    static decode(input, args) {
+        this.updateProtoRoot(args[0]);
+        this.showUnknownFields = args[1];
+        this.showTypes = args[2];
+        return this.mergeDecodes(input);
+    }
+
+    /**
+     * Update the parsedProto, throw parsing errors
+     *
+     * @param {string} protoText
+     */
+    static updateProtoRoot(protoText) {
+        try {
+            this.parsedProto = protobuf.parse(protoText);
+            if (this.parsedProto.package) {
+                this.parsedProto.root = this.parsedProto.root.nested[this.parsedProto.package];
+            }
+            this.updateMainMessageName();
+        } catch (error) {
+            throw new Error("Schema " + error);
+        }
+    }
+
+    /**
+     * Set mainMessageName to the first instance of a message defined in the schema that is not a submessage
+     *
+     */
+    static updateMainMessageName() {
+        const messageNames = [];
+        const fieldTypes = [];
+        this.parsedProto.root.nestedArray.forEach(block => {
+            if (block instanceof protobuf.Type) {
+                messageNames.push(block.name);
+                this.parsedProto.root.nested[block.name].fieldsArray.forEach(field => {
+                    fieldTypes.push(field.type);
+                });
+            }
+        });
+
+        if (messageNames.length === 0) {
+            this.mainMessageName = null;
+        } else {
+            // for (const name of messageNames) {
+            //     if (!fieldTypes.includes(name)) {
+            //         this.mainMessageName = name;
+            //         break;
+            //     }
+            // }
+            this.mainMessageName = messageNames[0];
+        }
+    }
+
+    /**
+     * Decode input using Protobufjs package and raw methods, compare, and merge results
+     *
+     * @param {byteArray} input
+     * @returns {Object}
+     */
+    static mergeDecodes(input) {
        const pb = new Protobuf(input);
-        return pb._parse();
+        let rawDecode = pb._parse();
+        let message;
+
+        if (this.showTypes) {
+            rawDecode = this.showRawTypes(rawDecode, pb.fieldTypes);
+            this.parsedProto.root = this.appendTypesToFieldNames(this.parsedProto.root);
+        }
+
+        try {
+            message = this.parsedProto.root.nested[this.mainMessageName];
+            const packageDecode = message.toObject(message.decode(input), {
+                bytes: String,
+                longs: Number,
+                enums: String,
+                defualts: true
+            });
+            const output = {};
+
+            if (this.showUnknownFields) {
+                output[message.name] = packageDecode;
+                output["Unknown Fields"] = this.compareFields(rawDecode, message);
+                return output;
+            } else {
+                return packageDecode;
+            }
+
+        } catch (error) {
+            if (message) {
+                throw new Error("Input " + error);
+            } else {
+                return rawDecode;
+            }
+        }
+    }
+
+    /**
+     * Replace fieldnames with fieldname and type
+     *
+     * @param {Object} schemaRoot
+     * @returns {Object}
+     */
+    static appendTypesToFieldNames(schemaRoot) {
+        for (const block of schemaRoot.nestedArray) {
+            if (block instanceof protobuf.Type) {
+                for (const [fieldName, fieldData] of Object.entries(block.fields)) {
+                    schemaRoot.nested[block.name].remove(block.fields[fieldName]);
+                    schemaRoot.nested[block.name].add(new protobuf.Field(`${fieldName} (${fieldData.type})`, fieldData.id, fieldData.type, fieldData.rule));
+                }
+            }
+        }
+        return schemaRoot;
+    }
+
+    /**
+     * Add field type to field name for fields in the raw decoded output
+     *
+     * @param {Object} rawDecode
+     * @param {Object} fieldTypes
+     * @returns {Object}
+     */
+    static showRawTypes(rawDecode, fieldTypes) {
+        for (const [fieldNum, value] of Object.entries(rawDecode)) {
+            const fieldType = fieldTypes[fieldNum];
+            let outputFieldValue;
+            let outputFieldType;
+
+            // Submessages
+            if (isNaN(fieldType)) {
+                outputFieldType = 2;
+
+                // Repeated submessages
+                if (Array.isArray(value)) {
+                    const fieldInstances = [];
+                    for (const instance of Object.keys(value)) {
+                        if (typeof(value[instance]) !== "string") {
+                            fieldInstances.push(this.showRawTypes(value[instance], fieldType));
+                        } else {
+                            fieldInstances.push(value[instance]);
+                        }
+                    }
+                    outputFieldValue = fieldInstances;
+
+                // Single submessage
+                } else {
+                    outputFieldValue = this.showRawTypes(value, fieldType);
+                }
+
+            // Non-submessage field
+            } else {
+                outputFieldType = fieldType;
+                outputFieldValue = value;
+            }
+
+            // Substitute fieldNum with field number and type
+            rawDecode[`field #${fieldNum}: ${this.getTypeInfo(outputFieldType)}`] = outputFieldValue;
+            delete rawDecode[fieldNum];
+        }
+        return rawDecode;
+    }
+
+    /**
+     * Compare raw decode to package decode and return discrepancies
+     *
+     * @param rawDecodedMessage
+     * @param schemaMessage
+     * @returns {Object}
+     */
+    static compareFields(rawDecodedMessage, schemaMessage) {
+        // Define message data using raw decode output and schema
+        const schemaFieldProperties = {};
+        const schemaFieldNames = Object.keys(schemaMessage.fields);
+        schemaFieldNames.forEach(field => schemaFieldProperties[schemaMessage.fields[field].id] = field);
+
+        // Loop over each field present in the raw decode output
+        for (const fieldName in rawDecodedMessage) {
+            let fieldId;
+            if (isNaN(fieldName)) {
+                fieldId = fieldName.match(/^field #(\d+)/)[1];
+            } else {
+                fieldId = fieldName;
+            }
+
+            // Check if this field is defined in the schema
+            if (fieldId in schemaFieldProperties) {
+                const schemaFieldName = schemaFieldProperties[fieldId];
+
+                // Extract the current field data from the raw decode and schema
+                const rawFieldData = rawDecodedMessage[fieldName];
+                const schemaField = schemaMessage.fields[schemaFieldName];
+
+                // Check for repeated fields
+                if (Array.isArray(rawFieldData) && !schemaField.repeated) {
+                    rawDecodedMessage[`(${schemaMessage.name}) ${schemaFieldName} is a repeated field`] = rawFieldData;
+                }
+
+                // Check for submessage fields
+                if (schemaField.resolvedType instanceof protobuf.Type) {
+                    const subMessageType = schemaMessage.fields[schemaFieldName].type;
+                    const schemaSubMessage = this.parsedProto.root.nested[subMessageType];
+                    const rawSubMessages = rawDecodedMessage[fieldName];
+                    let rawDecodedSubMessage = {};
+
+                    // Squash multiple submessage instances into one submessage
+                    if (Array.isArray(rawSubMessages)) {
+                        rawSubMessages.forEach(subMessageInstance => {
+                            const instanceFields = Object.entries(subMessageInstance);
+                            instanceFields.forEach(subField => {
+                                rawDecodedSubMessage[subField[0]] = subField[1];
+                            });
+                        });
+                    } else {
+                        rawDecodedSubMessage = rawSubMessages;
+                    }
+
+                    // Treat submessage as own message and compare its fields
+                    rawDecodedSubMessage = Protobuf.compareFields(rawDecodedSubMessage, schemaSubMessage);
+                    if (Object.entries(rawDecodedSubMessage).length !== 0) {
+                        rawDecodedMessage[`${schemaFieldName} (${subMessageType}) has missing fields`] = rawDecodedSubMessage;
+                    }
+                }
+                delete rawDecodedMessage[fieldName];
+            }
+        }
+        return rawDecodedMessage;
+    }
+
+    /**
+     * Returns wiretype information for input wiretype number
+     *
+     * @param {number} wireType
+     * @returns {string}
+     */
+    static getTypeInfo(wireType) {
+        switch (wireType) {
+            case 0:
+                return "VarInt (e.g. int32, bool)";
+            case 1:
+                return "64-Bit (e.g. fixed64, double)";
+            case 2:
+                return "L-delim (e.g. string, message)";
+            case 5:
+                return "32-Bit (e.g. fixed32, float)";
+        }
    }

    // Private Class Functions
@@ -143,6 +411,11 @@ class Protobuf {
        const header = this._fieldHeader();
        const type = header.type;
        const key = header.key;
+
+        if (typeof(this.fieldTypes[key]) !== "object") {
+            this.fieldTypes[key] = type;
+        }
+
        switch (type) {
            // varint
            case 0:
@@ -152,7 +425,7 @@ class Protobuf {
                return { "key": key, "value": this._uint64() };
            // length delimited
            case 2:
-                return { "key": key, "value": this._lenDelim() };
+                return { "key": key, "value": this._lenDelim(key) };
            // fixed 32
            case 5:
                return { "key": key, "value": this._uint32() };
@@ -237,10 +510,10 @@ class Protobuf {
     * @returns {number}
     */
    _uint64() {
-        // Read off a Uint64
-        let num = this.data[this.offset++] * 0x1000000 + (this.data[this.offset++] << 16) + (this.data[this.offset++] << 8) + this.data[this.offset++];
-        num = num * 0x100000000 + this.data[this.offset++] * 0x1000000 + (this.data[this.offset++] << 16) + (this.data[this.offset++] << 8) + this.data[this.offset++];
-        return num;
+        // Read off a Uint64 with little-endian
+        const lowerHalf = this.data[this.offset++] + (this.data[this.offset++] * 0x100) + (this.data[this.offset++] * 0x10000) + this.data[this.offset++] * 0x1000000;
+        const upperHalf = this.data[this.offset++] + (this.data[this.offset++] * 0x100) + (this.data[this.offset++] * 0x10000) + this.data[this.offset++] * 0x1000000;
+        return upperHalf * 0x100000000 + lowerHalf;
    }

    /**
@@ -249,7 +522,7 @@ class Protobuf {
     * @private
     * @returns {Object|string}
     */
-    _lenDelim() {
+    _lenDelim(fieldNum) {
        // Read off the field length
        const length = this._varInt();
        const fieldBytes = this.data.slice(this.offset, this.offset + length);
@@ -258,6 +531,10 @@ class Protobuf {
            // Attempt to parse as a new Protobuf Object
            const pbObject = new Protobuf(fieldBytes);
            field = pbObject._parse();
+
+            // Set field types object
+            this.fieldTypes[fieldNum] = {...this.fieldTypes[fieldNum], ...pbObject.fieldTypes};
+
        } catch (err) {
            // Otherwise treat as bytes
            field = Utils.byteArrayToChars(fieldBytes);
@@ -276,7 +553,7 @@ class Protobuf {
    _uint32() {
        // Use a dataview to read off the integer
        const dataview = new DataView(new Uint8Array(this.data.slice(this.offset, this.offset + 4)).buffer);
-        const value = dataview.getUint32(0);
+        const value = dataview.getUint32(0, true);
        this.offset += 4;
        return value;
    }
--- a/src/core/lib/PublicKey.mjs
+++ b/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 = "";
--- a/src/core/operations/AESDecrypt.mjs
+++ b/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
--- a/src/core/operations/AESEncrypt.mjs
+++ b/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
--- a/src/core/operations/CBORDecode.mjs
+++ b/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;
--- a/src/core/operations/CBOREncode.mjs
+++ b/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;
--- a/src/core/operations/ExtractFiles.mjs
+++ b/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>";
--- a/src/core/operations/FromBinary.mjs
+++ b/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 = [
--- a/src/core/operations/FuzzyMatch.mjs
+++ b/src/core/operations/FuzzyMatch.mjs
@@ -6,6 +6,7 @@

 import Operation from "../Operation.mjs";
 import {fuzzyMatch, calcMatchRanges, DEFAULT_WEIGHTS} from "../lib/FuzzyMatch.mjs";
+import Utils from "../Utils.mjs";

 /**
 * Fuzzy Match operation
@@ -101,16 +102,16 @@ class FuzzyMatch extends Operation {
            const matchRanges = calcMatchRanges(idxs);

            matchRanges.forEach(([start, length], i) => {
-                result += input.slice(pos, start);
+                result += Utils.escapeHtml(input.slice(pos, start));
                if (i === 0) result += `<span class="${hlClass}">`;
                pos = start + length;
-                result += `<b>${input.slice(start, pos)}</b>`;
+                result += `<b>${Utils.escapeHtml(input.slice(start, pos))}</b>`;
            });
            result += "</span>";
            hlClass = hlClass === "hl1" ? "hl2" : "hl1";
        });

-        result += input.slice(pos, input.length);
+        result += Utils.escapeHtml(input.slice(pos, input.length));

        return result;
    }
--- a/src/core/operations/HASSHClientFingerprint.mjs
+++ b/src/core/operations/HASSHClientFingerprint.mjs
@@ -0,0 +1,166 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ *
+ * HASSH created by Salesforce
+ *   Ben Reardon (@benreardon)
+ *   Adel Karimi (@0x4d31)
+ *   and the JA3 crew:
+ *     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";
+
+/**
+ * HASSH Client Fingerprint operation
+ */
+class HASSHClientFingerprint extends Operation {
+
+    /**
+     * HASSHClientFingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "HASSH Client Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a HASSH fingerprint to help identify SSH clients based on hashing together values from the Client Key Exchange Init message.<br><br>Input: A hex stream of the SSH_MSG_KEXINIT packet application layer from Client to Server.";
+        this.infoURL = "https://engineering.salesforce.com/open-sourcing-hassh-abed3ae5044c";
+        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", "HASSH algorithms 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));
+
+        // Length
+        const length = s.readInt(4);
+        if (s.length !== length + 4)
+            throw new OperationError("Incorrect packet length.");
+
+        // Padding length
+        const paddingLength = s.readInt(1);
+
+        // Message code
+        const messageCode = s.readInt(1);
+        if (messageCode !== 20)
+            throw new OperationError("Not a Key Exchange Init.");
+
+        // Cookie
+        s.moveForwardsBy(16);
+
+        // KEX Algorithms
+        const kexAlgosLength = s.readInt(4);
+        const kexAlgos = s.readString(kexAlgosLength);
+
+        // Server Host Key Algorithms
+        const serverHostKeyAlgosLength = s.readInt(4);
+        s.moveForwardsBy(serverHostKeyAlgosLength);
+
+        // Encryption Algorithms Client to Server
+        const encAlgosC2SLength = s.readInt(4);
+        const encAlgosC2S = s.readString(encAlgosC2SLength);
+
+        // Encryption Algorithms Server to Client
+        const encAlgosS2CLength = s.readInt(4);
+        s.moveForwardsBy(encAlgosS2CLength);
+
+        // MAC Algorithms Client to Server
+        const macAlgosC2SLength = s.readInt(4);
+        const macAlgosC2S = s.readString(macAlgosC2SLength);
+
+        // MAC Algorithms Server to Client
+        const macAlgosS2CLength = s.readInt(4);
+        s.moveForwardsBy(macAlgosS2CLength);
+
+        // Compression Algorithms Client to Server
+        const compAlgosC2SLength = s.readInt(4);
+        const compAlgosC2S = s.readString(compAlgosC2SLength);
+
+        // Compression Algorithms Server to Client
+        const compAlgosS2CLength = s.readInt(4);
+        s.moveForwardsBy(compAlgosS2CLength);
+
+        // Languages Client to Server
+        const langsC2SLength = s.readInt(4);
+        s.moveForwardsBy(langsC2SLength);
+
+        // Languages Server to Client
+        const langsS2CLength = s.readInt(4);
+        s.moveForwardsBy(langsS2CLength);
+
+        // First KEX packet follows
+        s.moveForwardsBy(1);
+
+        // Reserved
+        s.moveForwardsBy(4);
+
+        // Padding string
+        s.moveForwardsBy(paddingLength);
+
+        // Output
+        const hassh = [
+            kexAlgos,
+            encAlgosC2S,
+            macAlgosC2S,
+            compAlgosC2S
+        ];
+        const hasshStr = hassh.join(";");
+        const hasshHash = runHash("md5", Utils.strToArrayBuffer(hasshStr));
+
+        switch (outputFormat) {
+            case "HASSH algorithms string":
+                return hasshStr;
+            case "Full details":
+                return `Hash digest:
+${hasshHash}
+
+Full HASSH algorithms string:
+${hasshStr}
+
+Key Exchange Algorithms:
+${kexAlgos}
+Encryption Algorithms Client to Server:
+${encAlgosC2S}
+MAC Algorithms Client to Server:
+${macAlgosC2S}
+Compression Algorithms Client to Server:
+${compAlgosC2S}`;
+            case "Hash digest":
+            default:
+                return hasshHash;
+        }
+    }
+
+}
+
+export default HASSHClientFingerprint;
--- a/src/core/operations/HASSHServerFingerprint.mjs
+++ b/src/core/operations/HASSHServerFingerprint.mjs
@@ -0,0 +1,166 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ *
+ * HASSH created by Salesforce
+ *   Ben Reardon (@benreardon)
+ *   Adel Karimi (@0x4d31)
+ *   and the JA3 crew:
+ *     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";
+
+/**
+ * HASSH Server Fingerprint operation
+ */
+class HASSHServerFingerprint extends Operation {
+
+    /**
+     * HASSHServerFingerprint constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "HASSH Server Fingerprint";
+        this.module = "Crypto";
+        this.description = "Generates a HASSH fingerprint to help identify SSH servers based on hashing together values from the Server Key Exchange Init message.<br><br>Input: A hex stream of the SSH_MSG_KEXINIT packet application layer from Server to Client.";
+        this.infoURL = "https://engineering.salesforce.com/open-sourcing-hassh-abed3ae5044c";
+        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", "HASSH algorithms 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));
+
+        // Length
+        const length = s.readInt(4);
+        if (s.length !== length + 4)
+            throw new OperationError("Incorrect packet length.");
+
+        // Padding length
+        const paddingLength = s.readInt(1);
+
+        // Message code
+        const messageCode = s.readInt(1);
+        if (messageCode !== 20)
+            throw new OperationError("Not a Key Exchange Init.");
+
+        // Cookie
+        s.moveForwardsBy(16);
+
+        // KEX Algorithms
+        const kexAlgosLength = s.readInt(4);
+        const kexAlgos = s.readString(kexAlgosLength);
+
+        // Server Host Key Algorithms
+        const serverHostKeyAlgosLength = s.readInt(4);
+        s.moveForwardsBy(serverHostKeyAlgosLength);
+
+        // Encryption Algorithms Client to Server
+        const encAlgosC2SLength = s.readInt(4);
+        s.moveForwardsBy(encAlgosC2SLength);
+
+        // Encryption Algorithms Server to Client
+        const encAlgosS2CLength = s.readInt(4);
+        const encAlgosS2C = s.readString(encAlgosS2CLength);
+
+        // MAC Algorithms Client to Server
+        const macAlgosC2SLength = s.readInt(4);
+        s.moveForwardsBy(macAlgosC2SLength);
+
+        // MAC Algorithms Server to Client
+        const macAlgosS2CLength = s.readInt(4);
+        const macAlgosS2C = s.readString(macAlgosS2CLength);
+
+        // Compression Algorithms Client to Server
+        const compAlgosC2SLength = s.readInt(4);
+        s.moveForwardsBy(compAlgosC2SLength);
+
+        // Compression Algorithms Server to Client
+        const compAlgosS2CLength = s.readInt(4);
+        const compAlgosS2C = s.readString(compAlgosS2CLength);
+
+        // Languages Client to Server
+        const langsC2SLength = s.readInt(4);
+        s.moveForwardsBy(langsC2SLength);
+
+        // Languages Server to Client
+        const langsS2CLength = s.readInt(4);
+        s.moveForwardsBy(langsS2CLength);
+
+        // First KEX packet follows
+        s.moveForwardsBy(1);
+
+        // Reserved
+        s.moveForwardsBy(4);
+
+        // Padding string
+        s.moveForwardsBy(paddingLength);
+
+        // Output
+        const hassh = [
+            kexAlgos,
+            encAlgosS2C,
+            macAlgosS2C,
+            compAlgosS2C
+        ];
+        const hasshStr = hassh.join(";");
+        const hasshHash = runHash("md5", Utils.strToArrayBuffer(hasshStr));
+
+        switch (outputFormat) {
+            case "HASSH algorithms string":
+                return hasshStr;
+            case "Full details":
+                return `Hash digest:
+${hasshHash}
+
+Full HASSH algorithms string:
+${hasshStr}
+
+Key Exchange Algorithms:
+${kexAlgos}
+Encryption Algorithms Server to Client:
+${encAlgosS2C}
+MAC Algorithms Server to Client:
+${macAlgosS2C}
+Compression Algorithms Server to Client:
+${compAlgosS2C}`;
+            case "Hash digest":
+            default:
+                return hasshHash;
+        }
+    }
+
+}
+
+export default HASSHServerFingerprint;
--- a/src/core/operations/JA3Fingerprint.mjs
+++ b/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 packet 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;
--- a/src/core/operations/JA3SFingerprint.mjs
+++ b/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 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;
--- a/src/core/operations/JSONToCSV.mjs
+++ b/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 ||
--- a/src/core/operations/ParseIPv6Address.mjs
+++ b/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;
+                    }
+                }
            }


--- a/src/core/operations/ProtobufDecode.mjs
+++ b/src/core/operations/ProtobufDecode.mjs
@@ -20,12 +20,30 @@ class ProtobufDecode extends Operation {
        super();

        this.name = "Protobuf Decode";
-        this.module = "Default";
-        this.description = "Decodes any Protobuf encoded data to a JSON representation of the data using the field number as the field key.";
+        this.module = "Protobuf";
+        this.description = "Decodes any Protobuf encoded data to a JSON representation of the data using the field number as the field key.<br><br>If a .proto schema is defined, the encoded data will be decoded with reference to the schema. Only one message instance will be decoded. <br><br><u>Show Unknown Fields</u><br>When a schema is used, this option shows fields that are present in the input data but not defined in the schema.<br><br><u>Show Types</u><br>Show the type of a field next to its name. For undefined fields, the wiretype and example types are shown instead.";
        this.infoURL = "https://wikipedia.org/wiki/Protocol_Buffers";
        this.inputType = "ArrayBuffer";
        this.outputType = "JSON";
-        this.args = [];
+        this.args = [
+            {
+                name: "Schema (.proto text)",
+                type: "text",
+                value: "",
+                rows: 8,
+                hint: "Drag and drop is enabled on this ingredient"
+            },
+            {
+                name: "Show Unknown Fields",
+                type: "boolean",
+                value: false
+            },
+            {
+                name: "Show Types",
+                type: "boolean",
+                value: false
+            }
+        ];
    }

    /**
@@ -36,7 +54,7 @@ class ProtobufDecode extends Operation {
    run(input, args) {
        input = new Uint8Array(input);
        try {
-            return Protobuf.decode(input);
+            return Protobuf.decode(input, args);
        } catch (err) {
            throw new OperationError(err);
        }
--- a/src/core/operations/ProtobufEncode.mjs
+++ b/src/core/operations/ProtobufEncode.mjs
@@ -0,0 +1,54 @@
+/**
+ * @author GCHQ Contributor [3]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import Protobuf from "../lib/Protobuf.mjs";
+
+/**
+ * Protobuf Encode operation
+ */
+class ProtobufEncode extends Operation {
+
+    /**
+     * ProtobufEncode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Protobuf Encode";
+        this.module = "Protobuf";
+        this.description = "Encodes a valid JSON object into a protobuf byte array using the input .proto schema.";
+        this.infoURL = "https://developers.google.com/protocol-buffers/docs/encoding";
+        this.inputType = "JSON";
+        this.outputType = "ArrayBuffer";
+        this.args = [
+            {
+                name: "Schema (.proto text)",
+                type: "text",
+                value: "",
+                rows: 8,
+                hint: "Drag and drop is enabled on this ingredient"
+            }
+        ];
+    }
+
+    /**
+     * @param {Object} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        try {
+            return Protobuf.encode(input, args);
+        } catch (error) {
+            throw new OperationError(error);
+        }
+    }
+
+}
+
+export default ProtobufEncode;
--- a/src/core/operations/ToHexdump.mjs
+++ b/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);
--- a/src/node/api.mjs
+++ b/src/node/api.mjs
@@ -10,7 +10,7 @@

 import NodeDish from "./NodeDish.mjs";
 import NodeRecipe from "./NodeRecipe.mjs";
-import OperationConfig from "../core/config/OperationConfig.json";
+import OperationConfig from "../core/config/OperationConfig.json" assert {type: "json"};
 import { sanitise, removeSubheadingsFromArray, sentenceToCamelCase } from "./apiUtils.mjs";
 import ExcludedOperationError from "../core/errors/ExcludedOperationError.mjs";

--- a/src/node/cjs.js
+++ b/src/node/cjs.js
@@ -1,13 +0,0 @@
-/**
- * Export the main ESM module as CommonJS
- *
- *
- * @author d98762656 [d98762625@gmail.com]
- * @copyright Crown Copyright 2019
- * @license Apache-2.0
- */
-
-/* eslint no-global-assign: ["off"] */
-require = require("esm")(module);
-module.exports = require("./index.mjs");
-module.exports.File = require("./File.mjs");
--- a/src/node/config/scripts/generateNodeIndex.mjs
+++ b/src/node/config/scripts/generateNodeIndex.mjs
@@ -41,7 +41,7 @@ let code = `/**
 import NodeDish from "./NodeDish.mjs";
 import { _wrap, help, bake, _explainExcludedFunction } from "./api.mjs";
 import File from "./File.mjs";
-import { OperationError, DishError, ExcludedOperationError } from "../core/errors/index";
+import { OperationError, DishError, ExcludedOperationError } from "../core/errors/index.mjs";
 import {
    // import as core_ to avoid name clashes after wrap.
 `;
@@ -52,7 +52,7 @@ includedOperations.forEach((op) => {
 });

 code +=`
-} from "../core/operations/index";
+} from "../core/operations/index.mjs";

 global.File = File;

--- a/src/node/repl.mjs
+++ b/src/node/repl.mjs
@@ -7,8 +7,8 @@
 * @license Apache-2.0
 */

-const chef = require("./cjs.js");
-const repl = require("repl");
+import chef from "./index.mjs";
+import repl from "repl";


 /* eslint no-console: ["off"] */
--- a/src/node/wrapper.js
+++ b/src/node/wrapper.js
@@ -0,0 +1,11 @@
+/**
+ * Export the main ESM module as CommonJS
+ *
+ *
+ * @author d98762656 [d98762625@gmail.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+module.exports = (async () => await import("./index.mjs"))();
+module.exports.File = (async () => await import("./File.mjs"))();
--- a/src/web/App.mjs
+++ b/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);
    }


--- a/src/web/html/index.html
+++ b/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>

--- a/src/web/index.js
+++ b/src/web/index.js
@@ -17,8 +17,8 @@ import * as CanvasComponents from "../core/lib/CanvasComponents.mjs";

 // CyberChef
 import App from "./App.mjs";
-import Categories from "../core/config/Categories.json";
-import OperationConfig from "../core/config/OperationConfig.json";
+import Categories from "../core/config/Categories.json" assert {type: "json"};
+import OperationConfig from "../core/config/OperationConfig.json" assert {type: "json"};


 /**
--- a/src/web/static/sitemap.mjs
+++ b/src/web/static/sitemap.mjs
@@ -1,5 +1,5 @@
 import sm from "sitemap";
-import OperationConfig from "../../core/config/OperationConfig.json";
+import OperationConfig from "../../core/config/OperationConfig.json" assert {type: "json"};


 /**
--- a/src/web/waiters/ControlsWaiter.mjs
+++ b/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;
            }
        }

--- a/tests/node/consumers/cjs-consumer.js
+++ b/tests/node/consumers/cjs-consumer.js
@@ -6,24 +6,27 @@
 * @license Apache-2.0
 */

-const chef = require("cyberchef");
 const assert = require("assert");

-const d = chef.bake("Testing, 1 2 3", [
-    chef.toHex,
-    chef.reverse,
-    {
-        op: chef.unique,
-        args: {
-            delimiter: "Space",
-        }
-    },
-    {
-        op: chef.multiply,
-        args: {
-            delimiter: "Space",
-        }
-    }
-]);
+require("cyberchef").then(chef => {

-assert.equal(d.value, "630957449041920");
+    const d = chef.bake("Testing, 1 2 3", [
+        chef.toHex,
+        chef.reverse,
+        {
+            op: chef.unique,
+            args: {
+                delimiter: "Space",
+            }
+        },
+        {
+            op: chef.multiply,
+            args: {
+                delimiter: "Space",
+            }
+        }
+    ]);
+
+    assert.equal(d.value, "630957449041920");
+
+});
--- a/tests/node/consumers/esm-consumer.mjs
+++ b/tests/node/consumers/esm-consumer.mjs
@@ -7,8 +7,28 @@
 */
 import assert from "assert";
 import chef from "cyberchef";
+import { bake, toHex, reverse, unique, multiply } from "cyberchef";

-const d = chef.bake("Testing, 1 2 3", [
+const a = bake("Testing, 1 2 3", [
+    toHex,
+    reverse,
+    {
+        op: unique,
+        args: {
+            delimiter: "Space",
+        }
+    },
+    {
+        op: multiply,
+        args: {
+            delimiter: "Space",
+        }
+    }
+]);
+
+assert.equal(a.value, "630957449041920");
+
+const b = chef.bake("Testing, 1 2 3", [
    chef.toHex,
    chef.reverse,
    {
@@ -25,4 +45,4 @@ const d = chef.bake("Testing, 1 2 3", [
    }
 ]);

-assert.equal(d.value, "630957449041920");
+assert.equal(b.value, "630957449041920");
--- a/tests/node/consumers/esm-deep-import-consumer.mjs
+++ b/tests/node/consumers/esm-deep-import-consumer.mjs
@@ -1,28 +0,0 @@
-/**
- * Tests to ensure that a consuming app can use named imports from deep import patch
- *
- * @author d98762625 [d98762625@gmail.com]
- * @copyright Crown Copyright 2019
- * @license Apache-2.0
- */
-import assert from "assert";
-import { bake, toHex, reverse, unique, multiply } from "cyberchef/src/node/index.mjs";
-
-const d = bake("Testing, 1 2 3", [
-    toHex,
-    reverse,
-    {
-        op: unique,
-        args: {
-            delimiter: "Space",
-        }
-    },
-    {
-        op: multiply,
-        args: {
-            delimiter: "Space",
-        }
-    }
-]);
-
-assert.equal(d.value, "630957449041920");
--- a/tests/node/tests/Categories.mjs
+++ b/tests/node/tests/Categories.mjs
@@ -1,6 +1,6 @@
 import TestRegister from "../../lib/TestRegister.mjs";
-import Categories from "../../../src/core/config/Categories.json";
-import OperationConfig from "../../../src/core/config/OperationConfig.json";
+import Categories from "../../../src/core/config/Categories.json" assert {type: "json"};
+import OperationConfig from "../../../src/core/config/OperationConfig.json" assert {type: "json"};
 import it from "../assertionHandler.mjs";
 import assert from "assert";

--- a/tests/node/tests/operations.mjs
+++ b/tests/node/tests/operations.mjs
@@ -32,7 +32,7 @@ import {
    CSSMinify,
    toBase64,
    toHex
-} from "../../../src/node/index";
+} from "../../../src/node/index.mjs";
 import chef from "../../../src/node/index.mjs";
 import TestRegister from "../../lib/TestRegister.mjs";
 import File from "../../../src/node/File.mjs";
--- a/tests/operations/index.mjs
+++ b/tests/operations/index.mjs
@@ -102,6 +102,12 @@ 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";
+import "./tests/JA3SFingerprint.mjs";
+import "./tests/HASSH.mjs";
+

 // Cannot test operations that use the File type yet
 // import "./tests/SplitColourChannels.mjs";
--- a/tests/operations/tests/AvroToJSON.mjs
+++ b/tests/operations/tests/AvroToJSON.mjs
@@ -6,7 +6,7 @@
 * @license Apache-2.0
 */

-import TestRegister from "../../lib/TestRegister";
+import TestRegister from "../../lib/TestRegister.mjs";

 TestRegister.addTests([
    {
--- a/tests/operations/tests/BaconCipher.mjs
+++ b/tests/operations/tests/BaconCipher.mjs
@@ -5,8 +5,8 @@
 * @copyright Karsten Silkenbäumer 2019
 * @license Apache-2.0
 */
-import TestRegister from "../../lib/TestRegister";
-import { BACON_ALPHABETS, BACON_TRANSLATIONS } from "../../../src/core/lib/Bacon";
+import TestRegister from "../../lib/TestRegister.mjs";
+import { BACON_ALPHABETS, BACON_TRANSLATIONS } from "../../../src/core/lib/Bacon.mjs";

 const alphabets = Object.keys(BACON_ALPHABETS);
 const translations = BACON_TRANSLATIONS;
--- a/tests/operations/tests/CBORDecode.mjs
+++ b/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: []
+            }
+        ]
+    }
+]);
--- a/tests/operations/tests/CBOREncode.mjs
+++ b/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: []
+            }
+        ]
+    }
+]);
--- a/tests/operations/tests/Crypt.mjs
+++ b/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": ""}
                ]
            }
--- a/tests/operations/tests/HASSH.mjs
+++ b/tests/operations/tests/HASSH.mjs
@@ -0,0 +1,33 @@
+/**
+ * HASSH tests.
+ *
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "HASSH Client Fingerprint",
+        input: "000003140814c639665f5425dcb80bf9f0a048380a410000007e6469666669652d68656c6c6d616e2d67726f75702d65786368616e67652d7368613235362c6469666669652d68656c6c6d616e2d67726f75702d65786368616e67652d736861312c6469666669652d68656c6c6d616e2d67726f757031342d736861312c6469666669652d68656c6c6d616e2d67726f7570312d736861310000000f7373682d7273612c7373682d6473730000009d6165733132382d6374722c6165733139322d6374722c6165733235362d6374722c617263666f75723235362c617263666f75723132382c6165733132382d6362632c336465732d6362632c626c6f77666973682d6362632c636173743132382d6362632c6165733139322d6362632c6165733235362d6362632c617263666f75722c72696a6e6461656c2d636263406c797361746f722e6c69752e73650000009d6165733132382d6374722c6165733139322d6374722c6165733235362d6374722c617263666f75723235362c617263666f75723132382c6165733132382d6362632c336465732d6362632c626c6f77666973682d6362632c636173743132382d6362632c6165733139322d6362632c6165733235362d6362632c617263666f75722c72696a6e6461656c2d636263406c797361746f722e6c69752e736500000069686d61632d6d64352c686d61632d736861312c756d61632d3634406f70656e7373682e636f6d2c686d61632d726970656d643136302c686d61632d726970656d64313630406f70656e7373682e636f6d2c686d61632d736861312d39362c686d61632d6d64352d393600000069686d61632d6d64352c686d61632d736861312c756d61632d3634406f70656e7373682e636f6d2c686d61632d726970656d643136302c686d61632d726970656d64313630406f70656e7373682e636f6d2c686d61632d736861312d39362c686d61632d6d64352d39360000001a6e6f6e652c7a6c6962406f70656e7373682e636f6d2c7a6c69620000001a6e6f6e652c7a6c6962406f70656e7373682e636f6d2c7a6c6962000000000000000000000000000000000000000000",
+        expectedOutput: "21b457a327ce7a2d4fce5ef2c42400bd",
+        recipeConfig: [
+            {
+                "op": "HASSH Client Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    },
+    {
+        name: "HASSH Server Fingerprint",
+        input: "0000027c0b142c7bb93a1da21c9e54f5862e60a5597c000000596469666669652d68656c6c6d616e2d67726f75702d65786368616e67652d736861312c6469666669652d68656c6c6d616e2d67726f757031342d736861312c6469666669652d68656c6c6d616e2d67726f7570312d736861310000000f7373682d7273612c7373682d647373000000876165733132382d6362632c336465732d6362632c626c6f77666973682d6362632c636173743132382d6362632c617263666f75722c6165733139322d6362632c6165733235362d6362632c72696a6e6461656c2d636263406c797361746f722e6c69752e73652c6165733132382d6374722c6165733139322d6374722c6165733235362d637472000000876165733132382d6362632c336465732d6362632c626c6f77666973682d6362632c636173743132382d6362632c617263666f75722c6165733139322d6362632c6165733235362d6362632c72696a6e6461656c2d636263406c797361746f722e6c69752e73652c6165733132382d6374722c6165733139322d6374722c6165733235362d63747200000055686d61632d6d64352c686d61632d736861312c686d61632d726970656d643136302c686d61632d726970656d64313630406f70656e7373682e636f6d2c686d61632d736861312d39362c686d61632d6d64352d393600000055686d61632d6d64352c686d61632d736861312c686d61632d726970656d643136302c686d61632d726970656d64313630406f70656e7373682e636f6d2c686d61632d736861312d39362c686d61632d6d64352d3936000000096e6f6e652c7a6c6962000000096e6f6e652c7a6c6962000000000000000000000000000000000000000000000000",
+        expectedOutput: "f430cd6761697a6a658ee1d45ed22e49",
+        recipeConfig: [
+            {
+                "op": "HASSH Server Fingerprint",
+                "args": ["Hex", "Hash digest"]
+            }
+        ],
+    }
+]);
--- a/tests/operations/tests/JA3Fingerprint.mjs
+++ b/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"]
+            }
+        ],
+    },
+]);
--- a/tests/operations/tests/JA3SFingerprint.mjs
+++ b/tests/operations/tests/JA3SFingerprint.mjs
@@ -0,0 +1,57 @@
+/**
+ * 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"]
+            }
+        ],
+    },
+    // This Server Hello was based on draft 18 of the TLS1.3 spec which does not include a Session ID field, leading it to fail.
+    // The published version of TLS1.3 does require a legacy Session ID field (even if it is empty).
+    // {
+    //     name: "JA3S Fingerprint: TLS 1.3",
+    //     input: "16030100520200004e7f123ef1609fd3f4fa8668aac5822d500fb0639b22671d0fb7258597355795511bf61301002800280024001d0020ae0e282a3b7a463e71064ecbaf671586e979b0edbebf7a4735c31678c70f660c",
+    //     expectedOutput: "986ae432c402479fe7a0c6fbe02164c1",
+    //     recipeConfig: [
+    //         {
+    //             "op": "JA3S Fingerprint",
+    //             "args": ["Hex", "Hash digest"]
+    //         }
+    //     ],
+    // },
+]);
--- a/tests/operations/tests/Protobuf.mjs
+++ b/tests/operations/tests/Protobuf.mjs
@@ -10,10 +10,10 @@ import TestRegister from "../../lib/TestRegister.mjs";

 TestRegister.addTests([
    {
-        name: "Protobuf Decode",
+        name: "Protobuf Decode: no schema",
        input: "0d1c0000001203596f751a024d65202b2a0a0a066162633132331200",
        expectedOutput: JSON.stringify({
-            "1": 469762048,
+            "1": 28,
            "2": "You",
            "3": "Me",
            "4": 43,
@@ -29,7 +29,277 @@ TestRegister.addTests([
            },
            {
                "op": "Protobuf Decode",
-                "args": []
+                "args": ["", false, false]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Decode: partial schema, no unknown fields",
+        input: "0d1c0000001203596f751a024d65202b2a0a0a066162633132331200",
+        expectedOutput: JSON.stringify({
+            "Apple": [
+                28
+            ],
+            "Banana": "You",
+            "Carrot": [
+                "Me"
+            ]
+        }, null, 4),
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["Auto"]
+            },
+            {
+                "op": "Protobuf Decode",
+                "args": [
+                    `message Test {
+                    repeated fixed32 Apple = 1;
+                    optional string Banana = 2;
+                    repeated string Carrot = 3;
+                    }`,
+                    false,
+                    false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Decode: partial schema, show unknown fields",
+        input: "0d1c0000001203596f751a024d65202b2a0a0a066162633132331200",
+        expectedOutput: JSON.stringify({
+            "Test": {
+                "Apple": [
+                    28
+                ],
+                "Banana": "You",
+                "Carrot": [
+                    "Me"
+                ]
+            },
+            "Unknown Fields": {
+                "4": 43,
+                "5": {
+                    "1": "abc123",
+                    "2": {}
+                }
+            }
+        }, null, 4),
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["Auto"]
+            },
+            {
+                "op": "Protobuf Decode",
+                "args": [
+                    `message Test {
+                    repeated fixed32 Apple = 1;
+                    optional string Banana = 2;
+                    repeated string Carrot = 3;
+                    }`,
+                    true,
+                    false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Decode: full schema, no unknown fields",
+        input: "0d1c0000001203596f751a024d65202b2a0a0a06616263313233120031ff00000000000000",
+        expectedOutput: JSON.stringify({
+            "Apple": [
+                28
+            ],
+            "Banana": "You",
+            "Carrot": [
+                "Me"
+            ],
+            "Date": 43,
+            "Elderberry": {
+                "Fig": "abc123",
+                "Grape": {}
+            },
+            "Huckleberry": 255
+        }, null, 4),
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["Auto"]
+            },
+            {
+                "op": "Protobuf Decode",
+                "args": [
+                    `message Test {
+                        repeated fixed32 Apple = 1;
+                        optional string Banana = 2;
+                        repeated string Carrot = 3;
+                        optional int32 Date = 4;
+                        optional subTest Elderberry = 5;
+                        optional fixed64 Huckleberry = 6;
+                    }
+                    message subTest {
+                        optional string Fig = 1;
+                        optional subSubTest Grape = 2;
+                    }
+                    message subSubTest {}`,
+                    false,
+                    false
+                ]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Decode: partial schema, show unknown fields, show types",
+        input: "0d1c0000001203596f751a024d65202b2a0a0a06616263313233120031ba32a96cc10200003801",
+        expectedOutput: JSON.stringify({
+            "Test": {
+                "Banana (string)": "You",
+                "Carrot (string)": [
+                    "Me"
+                ],
+                "Date (int32)": 43,
+                "Imbe (Options)": "Option1"
+            },
+            "Unknown Fields": {
+                "field #1: 32-Bit (e.g. fixed32, float)": 28,
+                "field #5: L-delim (e.g. string, message)": {
+                    "field #1: L-delim (e.g. string, message)": "abc123",
+                    "field #2: L-delim (e.g. string, message)": {}
+                },
+                "field #6: 64-Bit (e.g. fixed64, double)": 3029774971578
+            }
+        }, null, 4),
+        recipeConfig: [
+            {
+                "op": "From Hex",
+                "args": ["Auto"]
+            },
+            {
+                "op": "Protobuf Decode",
+                "args": [
+                    `message Test {
+                        optional string Banana = 2;
+                        repeated string Carrot = 3;
+                        optional int32 Date = 4;
+                        optional Options Imbe = 7;
+                    }
+                    message subTest {
+                        optional string Fig = 1;
+                        optional subSubTest Grape = 2;
+                    }
+                    message subSubTest {}
+                    enum Options {
+                    Option0 = 0;
+                    Option1 = 1;
+                    Option2 = 2;
+                    }`,
+                    true,
+                    true
+                ]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Encode",
+        input: JSON.stringify({
+            "Apple": [
+                28
+            ],
+            "Banana": "You",
+            "Carrot": [
+                "Me"
+            ],
+            "Date": 43,
+            "Elderberry": {
+                "Fig": "abc123",
+                "Grape": {}
+            },
+            "Huckleberry": [3029774971578],
+            "Imbe": 1
+        }, null, 4),
+        expectedOutput: "0d1c0000001203596f751a024d65202b2a0a0a06616263313233120031ba32a96cc10200003801",
+        recipeConfig: [
+            {
+                "op": "Protobuf Encode",
+                "args": [
+                    `message Test {
+                        repeated fixed32 Apple = 1;
+                        optional string Banana = 2;
+                        repeated string Carrot = 3;
+                        optional int32 Date = 4;
+                        optional subTest Elderberry = 5;
+                        repeated fixed64 Huckleberry = 6;
+                        optional Options Imbe = 7;
+                    }
+                    message subTest {
+                        optional string Fig = 1;
+                        optional subSubTest Grape = 2;
+                    }
+                    message subSubTest {}
+                    enum Options {
+                    Option0 = 0;
+                    Option1 = 1;
+                    Option2 = 2;
+                    }`
+                ]
+            },
+            {
+                "op": "To Hex",
+                "args": [
+                    "None",
+                    0
+                ]
+            }
+        ]
+    },
+    {
+        name: "Protobuf Encode: incomplete schema",
+        input: JSON.stringify({
+            "Apple": [
+                28
+            ],
+            "Banana": "You",
+            "Carrot": [
+                "Me"
+            ],
+            "Date": 43,
+            "Elderberry": {
+                "Fig": "abc123",
+                "Grape": {}
+            },
+            "Huckleberry": [3029774971578],
+            "Imbe": 1
+        }, null, 4),
+        expectedOutput: "1203596f75202b2a0a0a06616263313233120031ba32a96cc1020000",
+        recipeConfig: [
+            {
+                "op": "Protobuf Encode",
+                "args": [
+                    `message Test {
+                        optional string Banana = 2;
+                        optional int32 Date = 4;
+                        optional subTest Elderberry = 5;
+                        repeated fixed64 Huckleberry = 6;
+                    }
+                    message subTest {
+                        optional string Fig = 1;
+                        optional subSubTest Grape = 2;
+                    }
+                    message subSubTest {}
+                    enum Options {
+                    Option0 = 0;
+                    Option1 = 1;
+                    Option2 = 2;
+                    }`
+                ]
+            },
+            {
+                "op": "To Hex",
+                "args": [
+                    "None",
+                    0
+                ]
            }
        ]
    },
--- a/tests/operations/tests/Register.mjs
+++ b/tests/operations/tests/Register.mjs
@@ -64,7 +64,10 @@ TestRegister.addTests([
                        "option": "Hex",
                        "string": ""
                    },
-                    ""
+                    {
+                        "option": "Hex",
+                        "string": ""
+                    }
                ]
            }
        ]
Author	SHA1	Message	Date
n1474335	1c0b83d833	9.33.0	2022-03-28 10:58:30 +01:00
n1474335	5c767d09b0	Updated CHANGELOG	2022-03-28 10:58:25 +01:00
n1474335	75dba51f56	Improve CJS and ESM module support #1037	2022-03-28 10:52:28 +01:00
n1474335	78a1827af8	Merge branch 'john19696-nodejs16'	2022-03-25 18:33:22 +00:00
n1474335	9e3733b33b	Fixed Node imports	2022-03-25 18:28:01 +00:00
n1474335	4ef65589e8	Actions can now be triggered manually	2022-03-25 15:24:21 +00:00
n1474335	cf9e670309	Updated eslint	2022-03-25 15:17:00 +00:00
n1474335	b09f98fbb4	Updated to Node 17	2022-03-25 14:59:54 +00:00
n1474335	e43e010163	Merge branch 'nodejs16' of https://github.com/john19696/CyberChef into john19696-nodejs16	2022-03-25 13:26:31 +00:00
n1073645	2a5cee0bd3	9.32.4	2022-03-23 09:31:17 +00:00
n1073645	c962bb79f5	Updated Dependencies	2022-03-23 09:28:32 +00:00
John L	2e23a33dfc	Merge branch 'nodejs16' of https://github.com/john19696/CyberChef into nodejs16	2022-02-04 11:03:05 +00:00
John L	bca296ee37	GitHub actions update	2022-02-04 11:02:52 +00:00
John L	2dbd647868	nodeFlags needs quote change	2022-01-31 11:39:17 +00:00
john19696	2991e7d1fe	Update Gruntfile.js add nodeFlags	2022-01-31 10:31:19 +00:00
John L	f6f12fc193	chromedriver update	2022-01-27 17:18:31 +00:00
john19696	1fac8c1cea	Merge pull request #1 from t-8ch/nodejs16 Node 16 compatibility	2022-01-21 15:05:16 +00:00
Thomas Weißschuh	cfc29ef821	Always use mjs imports This is needed for Node/NPM 16 compat	2021-09-17 08:48:04 +02:00
Thomas Weißschuh	83c6775038	Support json modules This is need for builds on Node/NPM 16	2021-09-17 08:45:56 +02:00
n1474335	ae1b12c120	9.32.3	2021-09-03 14:58:53 +01:00
n1474335	c423de545f	Switch XOR input and output differential logic. Fixes #1155	2021-09-03 14:58:48 +01:00
n1474335	84011371b7	9.32.2	2021-08-26 16:51:50 +01:00
n1474335	f831ec6b7e	Fixed issues in Protobuf parsing	2021-08-26 16:51:42 +01:00
n1474335	05bfa9158d	9.32.1	2021-08-19 12:06:30 +01:00
n1474335	649016bc85	Updated dependencies	2021-08-19 12:06:26 +01:00
n1474335	7492b874cf	9.32.0	2021-08-18 17:23:43 +01:00
n1474335	9ea21af61f	Updated CHANGELOG	2021-08-18 17:23:38 +01:00
n1474335	dd18e52993	Protobuf operations improved to enable full and partial schema support	2021-08-18 17:22:09 +01:00
n1474335	a4a13666e6	9.31.0	2021-08-10 16:51:28 +01:00
n1474335	07ef4da892	Updated CHANGELOG	2021-08-10 16:50:59 +01:00
n1474335	e9ca4dc9ca	Added HASSH operations	2021-08-10 16:48:35 +01:00
n1474335	57bb8fbc45	9.30.0	2021-08-10 15:00:10 +01:00
n1474335	9175624210	Updated CHANGELOG	2021-08-10 15:00:04 +01:00
n1474335	289a417dfb	Added 'JA3S Fingerprint' operation	2021-08-10 14:57:34 +01:00
n1474335	8379a9b275	Skipping UI tests in GitHub Actions	2021-08-10 14:26:33 +01:00
n1474335	5b1fad118f	Fixed chromedriver path	2021-07-28 15:56:01 +01:00
n1474335	5e8985810e	9.29.2	2021-07-28 15:35:29 +01:00
n1474335	d2568e2a29	Updated dependencies	2021-07-28 15:35:24 +01:00
n1474335	6dfc21ef06	9.29.1	2021-07-28 14:58:17 +01:00
n1474335	1f19f2f58c	Updated chromedriver	2021-07-28 14:58:09 +01:00
n1474335	1728cc7a85	9.29.0	2021-07-28 14:37:05 +01:00
n1474335	fa2fc2ba33	Updated CHANGELOG	2021-07-28 14:36:14 +01:00
n1474335	9a33498fed	Added 'TLS JA3 Fingerprint' operation	2021-07-28 14:32:39 +01:00
n1474335	a3b873fd96	9.28.0	2021-03-26 14:09:51 +00:00
n1474335	97bd03799e	Updated CHANGELOG	2021-03-26 14:09:37 +00:00
n1474335	ffaaaae2b4	Merge branch 'Danh4-issue-991'	2021-03-26 14:07:18 +00:00
n1474335	ff88d30d2f	Tidied up CBOR operations	2021-03-26 14:07:02 +00:00
n1474335	88e3c2ccb2	Merge branch 'issue-991' of https://github.com/Danh4/CyberChef into Danh4-issue-991	2021-03-26 13:59:16 +00:00
n1474335	5029356514	Added link to FAQ description about output handling	2021-03-05 10:50:38 +00:00
n1474335	e57d5a7e75	9.27.6	2021-02-23 15:11:22 +00:00
n1474335	2bbe54cdcd	Added further deconstruction of IPv6 Multicast Addresses in the 'Parse IPv6 Address' operation	2021-02-23 15:11:16 +00:00
n1474335	0e2423c390	9.27.5	2021-02-22 19:33:56 +00:00
n1474335	8fadad5891	AES Additional data can now be entered in a range of formats. #1011	2021-02-22 19:33:52 +00:00
n1474335	32455cd20f	9.27.4	2021-02-22 19:13:47 +00:00
n1474335	1e0e7f16a7	Added numeric validation for arguments in Binary and Hex operattions. Fixes #1178	2021-02-22 19:13:38 +00:00
n1474335	95884d77cf	Extractable file formats are now listed properly in the 'Extract Files' description	2021-02-17 15:01:42 +00:00
n1474335	b69373f5e7	Fixed 'JSON to CSV' data flattening.	2021-02-16 14:48:56 +00:00
n1474335	61e85474d3	9.27.3	2021-02-16 14:36:36 +00:00
n1474335	3a9bdc58af	Fixed 'JSON to CSV' handling of complex structures. Closes #637	2021-02-16 14:36:31 +00:00
n1474335	59c1c45d78	Updated dependencies	2021-02-16 14:17:09 +00:00
n1474335	b5f6cedd30	9.27.2	2021-02-16 14:12:18 +00:00
n1474335	c879af6860	Fixed 'Save recipe' URL generation issue. Closes #1176	2021-02-16 14:12:14 +00:00
n1474335	22fe5a6ae7	9.27.1	2021-02-12 17:55:36 +00:00
n1474335	57714c86a6	Escape HTML input in Fuzzy Match operation	2021-02-12 17:55:28 +00:00
71819	209fc07eac	Issue 991: Add CBOR Decode operation	2020-03-30 11:31:25 +01:00
71819	ae70cb89ed	Issue 991: Add CBOR Encode operation	2020-03-30 11:31:25 +01:00