9.28.0

Updated CHANGELOG
Merge branch 'Danh4-issue-991'
2021-03-26 14:09:51 +00:00 · 2021-03-26 14:09:37 +00:00 · 2021-03-26 14:07:18 +00:00 · 2021-03-26 14:07:02 +00:00 · 2021-03-26 13:59:16 +00:00 · 2021-03-05 10:50:38 +00:00
36 changed files with 2951 additions and 800 deletions
@@ -19,7 +19,7 @@ jobs:
    - name: Install
      run: |
        npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize

    - name: Lint
      run: npx grunt lint
@@ -18,7 +18,7 @@ jobs:
    - name: Install
      run: |
        npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize

    - name: Lint
      run: npx grunt lint
@@ -19,7 +19,7 @@ jobs:
    - name: Install
      run: |
        npm install
-        export NODE_OPTIONS=--max_old_space_size=2048
+        npm run setheapsize

    - name: Lint
      run: npx grunt lint
@@ -13,6 +13,15 @@ All major and minor version changes will be documented in this file. Details of

 ## Details

+### [9.28.0] - 2021-03-26
+- 'CBOR Encode' and 'CBOR Decode' operations added [@Danh4] | [#999]
+
+### [9.27.0] - 2021-02-12
+- 'Fuzzy Match' operation added [@n1474335] | [8ad18b]
+
+### [9.26.0] - 2021-02-11
+- 'Get Time' operation added [@n1073645] [@n1474335] | [#1045]
+
 ### [9.25.0] - 2021-02-11
 - 'Extract ID3' operation added [@n1073645] [@n1474335] | [#1006]

@@ -250,6 +259,9 @@ All major and minor version changes will be documented in this file. Details of



+[9.28.0]: https://github.com/gchq/CyberChef/releases/tag/v9.28.0
+[9.27.0]: https://github.com/gchq/CyberChef/releases/tag/v9.27.0
+[9.26.0]: https://github.com/gchq/CyberChef/releases/tag/v9.26.0
 [9.25.0]: https://github.com/gchq/CyberChef/releases/tag/v9.25.0
 [9.24.0]: https://github.com/gchq/CyberChef/releases/tag/v9.24.0
 [9.23.0]: https://github.com/gchq/CyberChef/releases/tag/v9.23.0
@@ -355,6 +367,9 @@ All major and minor version changes will be documented in this file. Details of
 [@MarvinJWendt]: https://github.com/MarvinJWendt
 [@dmfj]: https://github.com/dmfj
 [@mattnotmitt]: https://github.com/mattnotmitt
+[@Danh4]: https://github.com/Danh4
+
+[8ad18b]: https://github.com/gchq/CyberChef/commit/8ad18bc7db6d9ff184ba3518686293a7685bf7b7

 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -428,7 +443,9 @@ All major and minor version changes will be documented in this file. Details of
 [#965]: https://github.com/gchq/CyberChef/pull/965
 [#966]: https://github.com/gchq/CyberChef/pull/966
 [#987]: https://github.com/gchq/CyberChef/pull/987
+[#999]: https://github.com/gchq/CyberChef/pull/999
 [#1006]: https://github.com/gchq/CyberChef/pull/1006
 [#1022]: https://github.com/gchq/CyberChef/pull/1022
+[#1045]: https://github.com/gchq/CyberChef/pull/1045
 [#1049]: https://github.com/gchq/CyberChef/pull/1049
 [#1083]: https://github.com/gchq/CyberChef/pull/1083
@@ -1,6 +1,7 @@
 # CyberChef

-[![Build Status](https://travis-ci.org/gchq/CyberChef.svg?branch=master)](https://travis-ci.org/gchq/CyberChef)
+[![](https://github.com/gchq/CyberChef/workflows/Master%20Build,%20Test%20&%20Deploy/badge.svg)](https://github.com/gchq/CyberChef/actions?query=workflow%3A%22Master+Build%2C+Test+%26+Deploy%22)
+[![Language grade: JavaScript](https://img.shields.io/lgtm/grade/javascript/g/gchq/CyberChef.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/gchq/CyberChef/context:javascript)
 [![dependencies Status](https://david-dm.org/gchq/CyberChef/status.svg)](https://david-dm.org/gchq/CyberChef)
 [![npm](https://img.shields.io/npm/v/cyberchef.svg)](https://www.npmjs.com/package/cyberchef)
 [![](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/gchq/CyberChef/blob/master/LICENSE)
@@ -1,6 +1,6 @@
 {
  "name": "cyberchef",
-  "version": "9.25.0",
+  "version": "9.28.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",
@@ -36,9 +36,9 @@
    "node >= 10"
  ],
  "devDependencies": {
-    "@babel/core": "^7.12.10",
-    "@babel/plugin-transform-runtime": "^7.12.10",
-    "@babel/preset-env": "^7.12.11",
+    "@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",
@@ -47,8 +47,8 @@
    "cli-progress": "^3.9.0",
    "colors": "^1.4.0",
    "copy-webpack-plugin": "^7.0.0",
-    "css-loader": "^5.0.1",
-    "eslint": "^7.19.0",
+    "css-loader": "^5.0.2",
+    "eslint": "^7.20.0",
    "exports-loader": "^2.0.0",
    "file-loader": "^6.2.0",
    "grunt": "^1.3.0",
@@ -62,30 +62,30 @@
    "grunt-exec": "~3.0.0",
    "grunt-webpack": "^4.0.2",
    "grunt-zip": "^0.18.2",
-    "html-webpack-plugin": "^4.5.1",
+    "html-webpack-plugin": "^5.1.0",
    "imports-loader": "^2.0.0",
-    "mini-css-extract-plugin": "^1.3.5",
+    "mini-css-extract-plugin": "^1.3.7",
    "nightwatch": "^1.5.1",
    "node-sass": "^5.0.0",
-    "postcss": "^8.2.4",
+    "postcss": "^8.2.6",
    "postcss-css-variables": "^0.17.0",
    "postcss-import": "^14.0.0",
-    "postcss-loader": "^4.2.0",
+    "postcss-loader": "^5.0.0",
    "prompt": "^1.1.0",
-    "sass-loader": "^10.1.1",
-    "sitemap": "^6.3.5",
+    "sass-loader": "^11.0.1",
+    "sitemap": "^6.3.6",
    "style-loader": "^2.0.0",
    "svg-url-loader": "^7.1.1",
    "url-loader": "^4.1.1",
-    "webpack": "^5.19.0",
+    "webpack": "^5.22.0",
    "webpack-bundle-analyzer": "^4.4.0",
    "webpack-dev-server": "^3.11.2",
    "webpack-node-externals": "^2.5.2",
-    "worker-loader": "^3.0.7"
+    "worker-loader": "^3.0.8"
  },
  "dependencies": {
    "@babel/polyfill": "^7.12.1",
-    "@babel/runtime": "^7.12.5",
+    "@babel/runtime": "^7.12.13",
    "arrive": "^2.4.1",
    "avsc": "^5.5.3",
    "babel-plugin-transform-builtin-extend": "1.1.2",
@@ -98,6 +98,7 @@
    "browserify-zlib": "^0.2.0",
    "bson": "^4.2.2",
    "buffer": "^6.0.3",
+    "cbor": "^5.0.1",
    "chi-squared": "^1.1.0",
    "codepage": "^1.14.0",
    "core-js": "^3.8.3",
@@ -115,8 +116,8 @@
    "exif-parser": "^0.1.12",
    "file-saver": "^2.0.5",
    "flat": "^5.0.2",
-    "geodesy": "^1.1.3",
-    "highlight.js": "^10.5.0",
+    "geodesy": "1.1.3",
+    "highlight.js": "^10.6.0",
    "jimp": "^0.16.1",
    "jquery": "3.5.1",
    "js-crc": "^0.2.0",
@@ -125,7 +126,7 @@
    "jsonpath": "^1.1.0",
    "jsonwebtoken": "^8.5.1",
    "jsqr": "^1.3.1",
-    "jsrsasign": "10.1.5",
+    "jsrsasign": "^10.1.10",
    "kbpgp": "2.1.15",
    "libbzip2-wasm": "0.0.4",
    "libyara-wasm": "^1.1.0",
@@ -134,14 +135,14 @@
    "loglevel-message-prefix": "^3.0.0",
    "markdown-it": "^12.0.4",
    "moment": "^2.29.1",
-    "moment-timezone": "^0.5.32",
+    "moment-timezone": "^0.5.33",
    "ngeohash": "^0.6.3",
    "node-forge": "^0.10.0",
    "node-md6": "^0.1.0",
    "nodom": "^2.4.0",
    "notepack.io": "^2.3.0",
    "nwmatcher": "^1.4.4",
-    "otp": "^0.1.3",
+    "otp": "0.1.3",
    "path": "^0.12.7",
    "popper.js": "^1.16.1",
    "process": "^0.11.10",
@@ -152,15 +153,15 @@
    "split.js": "^1.6.2",
    "ssdeep.js": "0.0.2",
    "stream-browserify": "^3.0.0",
-    "terser": "^5.5.1",
-    "tesseract.js": "^2.1.1",
-    "ua-parser-js": "^0.7.23",
+    "terser": "^5.6.0",
+    "tesseract.js": "2.1.1",
+    "ua-parser-js": "^0.7.24",
    "unorm": "^1.6.0",
    "utf8": "^3.0.0",
    "vkbeautify": "^0.99.3",
    "xmldom": "^0.4.0",
    "xpath": "0.0.32",
-    "xregexp": "^4.4.1",
+    "xregexp": "^5.0.1",
    "zlibjs": "^0.3.1"
  },
  "scripts": {
@@ -173,6 +174,8 @@
    "testuidev": "npx nightwatch --env=dev",
    "lint": "npx grunt lint",
    "postinstall": "npx grunt exec:fixCryptoApiImports",
-    "newop": "node --experimental-modules src/core/config/scripts/newOperation.mjs"
+    "newop": "node --experimental-modules src/core/config/scripts/newOperation.mjs",
+    "getheapsize": "node -e 'console.log(`node heap limit = ${require(\"v8\").getHeapStatistics().heap_size_limit / (1024 * 1024)} Mb`)'",
+    "setheapsize": "export NODE_OPTIONS=--max_old_space_size=2048"
  }
 }
@@ -170,13 +170,18 @@ class Utils {
     *
     * @param {string} str - The input string to display.
     * @param {boolean} [preserveWs=false] - Whether or not to print whitespace.
+     * @param {boolean} [onlyAscii=false] - Whether or not to replace non ASCII characters.
     * @returns {string}
     */
-    static printable(str, preserveWs=false) {
+    static printable(str, preserveWs=false, onlyAscii=false) {
        if (isWebEnvironment() && window.app && !window.app.options.treatAsUtf8) {
            str = Utils.byteArrayToChars(Utils.strToByteArray(str));
        }

+        if (onlyAscii) {
+            return str.replace(/[^\x20-\x7f]/g, ".");
+        }
+
        // eslint-disable-next-line no-misleading-character-class
        const re = /[\0-\x08\x0B-\x0C\x0E-\x1F\x7F-\x9F\xAD\u0378\u0379\u037F-\u0383\u038B\u038D\u03A2\u0528-\u0530\u0557\u0558\u0560\u0588\u058B-\u058E\u0590\u05C8-\u05CF\u05EB-\u05EF\u05F5-\u0605\u061C\u061D\u06DD\u070E\u070F\u074B\u074C\u07B2-\u07BF\u07FB-\u07FF\u082E\u082F\u083F\u085C\u085D\u085F-\u089F\u08A1\u08AD-\u08E3\u08FF\u0978\u0980\u0984\u098D\u098E\u0991\u0992\u09A9\u09B1\u09B3-\u09B5\u09BA\u09BB\u09C5\u09C6\u09C9\u09CA\u09CF-\u09D6\u09D8-\u09DB\u09DE\u09E4\u09E5\u09FC-\u0A00\u0A04\u0A0B-\u0A0E\u0A11\u0A12\u0A29\u0A31\u0A34\u0A37\u0A3A\u0A3B\u0A3D\u0A43-\u0A46\u0A49\u0A4A\u0A4E-\u0A50\u0A52-\u0A58\u0A5D\u0A5F-\u0A65\u0A76-\u0A80\u0A84\u0A8E\u0A92\u0AA9\u0AB1\u0AB4\u0ABA\u0ABB\u0AC6\u0ACA\u0ACE\u0ACF\u0AD1-\u0ADF\u0AE4\u0AE5\u0AF2-\u0B00\u0B04\u0B0D\u0B0E\u0B11\u0B12\u0B29\u0B31\u0B34\u0B3A\u0B3B\u0B45\u0B46\u0B49\u0B4A\u0B4E-\u0B55\u0B58-\u0B5B\u0B5E\u0B64\u0B65\u0B78-\u0B81\u0B84\u0B8B-\u0B8D\u0B91\u0B96-\u0B98\u0B9B\u0B9D\u0BA0-\u0BA2\u0BA5-\u0BA7\u0BAB-\u0BAD\u0BBA-\u0BBD\u0BC3-\u0BC5\u0BC9\u0BCE\u0BCF\u0BD1-\u0BD6\u0BD8-\u0BE5\u0BFB-\u0C00\u0C04\u0C0D\u0C11\u0C29\u0C34\u0C3A-\u0C3C\u0C45\u0C49\u0C4E-\u0C54\u0C57\u0C5A-\u0C5F\u0C64\u0C65\u0C70-\u0C77\u0C80\u0C81\u0C84\u0C8D\u0C91\u0CA9\u0CB4\u0CBA\u0CBB\u0CC5\u0CC9\u0CCE-\u0CD4\u0CD7-\u0CDD\u0CDF\u0CE4\u0CE5\u0CF0\u0CF3-\u0D01\u0D04\u0D0D\u0D11\u0D3B\u0D3C\u0D45\u0D49\u0D4F-\u0D56\u0D58-\u0D5F\u0D64\u0D65\u0D76-\u0D78\u0D80\u0D81\u0D84\u0D97-\u0D99\u0DB2\u0DBC\u0DBE\u0DBF\u0DC7-\u0DC9\u0DCB-\u0DCE\u0DD5\u0DD7\u0DE0-\u0DF1\u0DF5-\u0E00\u0E3B-\u0E3E\u0E5C-\u0E80\u0E83\u0E85\u0E86\u0E89\u0E8B\u0E8C\u0E8E-\u0E93\u0E98\u0EA0\u0EA4\u0EA6\u0EA8\u0EA9\u0EAC\u0EBA\u0EBE\u0EBF\u0EC5\u0EC7\u0ECE\u0ECF\u0EDA\u0EDB\u0EE0-\u0EFF\u0F48\u0F6D-\u0F70\u0F98\u0FBD\u0FCD\u0FDB-\u0FFF\u10C6\u10C8-\u10CC\u10CE\u10CF\u1249\u124E\u124F\u1257\u1259\u125E\u125F\u1289\u128E\u128F\u12B1\u12B6\u12B7\u12BF\u12C1\u12C6\u12C7\u12D7\u1311\u1316\u1317\u135B\u135C\u137D-\u137F\u139A-\u139F\u13F5-\u13FF\u169D-\u169F\u16F1-\u16FF\u170D\u1715-\u171F\u1737-\u173F\u1754-\u175F\u176D\u1771\u1774-\u177F\u17DE\u17DF\u17EA-\u17EF\u17FA-\u17FF\u180F\u181A-\u181F\u1878-\u187F\u18AB-\u18AF\u18F6-\u18FF\u191D-\u191F\u192C-\u192F\u193C-\u193F\u1941-\u1943\u196E\u196F\u1975-\u197F\u19AC-\u19AF\u19CA-\u19CF\u19DB-\u19DD\u1A1C\u1A1D\u1A5F\u1A7D\u1A7E\u1A8A-\u1A8F\u1A9A-\u1A9F\u1AAE-\u1AFF\u1B4C-\u1B4F\u1B7D-\u1B7F\u1BF4-\u1BFB\u1C38-\u1C3A\u1C4A-\u1C4C\u1C80-\u1CBF\u1CC8-\u1CCF\u1CF7-\u1CFF\u1DE7-\u1DFB\u1F16\u1F17\u1F1E\u1F1F\u1F46\u1F47\u1F4E\u1F4F\u1F58\u1F5A\u1F5C\u1F5E\u1F7E\u1F7F\u1FB5\u1FC5\u1FD4\u1FD5\u1FDC\u1FF0\u1FF1\u1FF5\u1FFF\u200B-\u200F\u202A-\u202E\u2060-\u206F\u2072\u2073\u208F\u209D-\u209F\u20BB-\u20CF\u20F1-\u20FF\u218A-\u218F\u23F4-\u23FF\u2427-\u243F\u244B-\u245F\u2700\u2B4D-\u2B4F\u2B5A-\u2BFF\u2C2F\u2C5F\u2CF4-\u2CF8\u2D26\u2D28-\u2D2C\u2D2E\u2D2F\u2D68-\u2D6E\u2D71-\u2D7E\u2D97-\u2D9F\u2DA7\u2DAF\u2DB7\u2DBF\u2DC7\u2DCF\u2DD7\u2DDF\u2E3C-\u2E7F\u2E9A\u2EF4-\u2EFF\u2FD6-\u2FEF\u2FFC-\u2FFF\u3040\u3097\u3098\u3100-\u3104\u312E-\u3130\u318F\u31BB-\u31BF\u31E4-\u31EF\u321F\u32FF\u4DB6-\u4DBF\u9FCD-\u9FFF\uA48D-\uA48F\uA4C7-\uA4CF\uA62C-\uA63F\uA698-\uA69E\uA6F8-\uA6FF\uA78F\uA794-\uA79F\uA7AB-\uA7F7\uA82C-\uA82F\uA83A-\uA83F\uA878-\uA87F\uA8C5-\uA8CD\uA8DA-\uA8DF\uA8FC-\uA8FF\uA954-\uA95E\uA97D-\uA97F\uA9CE\uA9DA-\uA9DD\uA9E0-\uA9FF\uAA37-\uAA3F\uAA4E\uAA4F\uAA5A\uAA5B\uAA7C-\uAA7F\uAAC3-\uAADA\uAAF7-\uAB00\uAB07\uAB08\uAB0F\uAB10\uAB17-\uAB1F\uAB27\uAB2F-\uABBF\uABEE\uABEF\uABFA-\uABFF\uD7A4-\uD7AF\uD7C7-\uD7CA\uD7FC-\uD7FF\uE000-\uF8FF\uFA6E\uFA6F\uFADA-\uFAFF\uFB07-\uFB12\uFB18-\uFB1C\uFB37\uFB3D\uFB3F\uFB42\uFB45\uFBC2-\uFBD2\uFD40-\uFD4F\uFD90\uFD91\uFDC8-\uFDEF\uFDFE\uFDFF\uFE1A-\uFE1F\uFE27-\uFE2F\uFE53\uFE67\uFE6C-\uFE6F\uFE75\uFEFD-\uFF00\uFFBF-\uFFC1\uFFC8\uFFC9\uFFD0\uFFD1\uFFD8\uFFD9\uFFDD-\uFFDF\uFFE7\uFFEF-\uFFFB\uFFFE\uFFFF]/g;
        const wsRe = /[\x09-\x10\x0D\u2028\u2029]/g;
@@ -890,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
@@ -61,7 +61,9 @@
            "Parse TLV",
            "CSV to JSON",
            "JSON to CSV",
-            "Avro to JSON"
+            "Avro to JSON",
+            "CBOR Encode",
+            "CBOR Decode"
        ]
    },
    {
@@ -238,6 +240,7 @@
            "Pad lines",
            "Find / Replace",
            "Regular expression",
+            "Fuzzy Match",
            "Offset checker",
            "Hamming Distance",
            "Convert distance",
@@ -267,6 +270,7 @@
            "Windows Filetime to UNIX Timestamp",
            "UNIX Timestamp to Windows Filetime",
            "Extract dates",
+            "Get Time",
            "Sleep"
        ]
    },
@@ -148,4 +148,8 @@ export const ALPHABET_OPTIONS = [
    {name: "BinHex: !-,-0-689@A-NP-VX-Z[`a-fh-mp-r", value: "!-,-0-689@A-NP-VX-Z[`a-fh-mp-r"},
    {name: "ROT13: N-ZA-Mn-za-m0-9+/=", value: "N-ZA-Mn-za-m0-9+/="},
    {name: "UNIX crypt: ./0-9A-Za-z", value: "./0-9A-Za-z"},
+    {name: "Atom128: /128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC", value: "/128GhIoPQROSTeUbADfgHijKLM+n0pFWXY456xyzB7=39VaqrstJklmNuZvwcdEC"},
+    {name: "Megan35: 3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5", value: "3GHIJKLMNOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5"},
+    {name: "Zong22: ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2", value: "ZKj9n+yf0wDVX1s/5YbdxSo=ILaUpPBCHg8uvNO4klm6iJGhQ7eFrWczAMEq3RTt2"},
+    {name: "Hazz15: HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5", value: "HNO4klm6ij9n+J2hyf0gzA8uvwDEq3X1Q7ZKeFrWcVTts/MRGYbdxSo=ILaUpPBC5"}
 ];
@@ -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, "");

@@ -16,40 +16,72 @@
 *   Anurag Awasthi - updated to 0.2.0
 */

-const SEQUENTIAL_BONUS = 15; // bonus for adjacent matches
-const SEPARATOR_BONUS = 30; // bonus if match occurs after a separator
-const CAMEL_BONUS = 30; // bonus if match is uppercase and prev is lower
-const FIRST_LETTER_BONUS = 15; // bonus if the first letter is matched
+export const DEFAULT_WEIGHTS = {
+    sequentialBonus: 15, // bonus for adjacent matches
+    separatorBonus: 30, // bonus if match occurs after a separator
+    camelBonus: 30, // bonus if match is uppercase and prev is lower
+    firstLetterBonus: 15, // bonus if the first letter is matched

-const LEADING_LETTER_PENALTY = -5; // penalty applied for every letter in str before the first match
-const MAX_LEADING_LETTER_PENALTY = -15; // maximum penalty for leading letters
-const UNMATCHED_LETTER_PENALTY = -1;
+    leadingLetterPenalty: -5, // penalty applied for every letter in str before the first match
+    maxLeadingLetterPenalty: -15, // maximum penalty for leading letters
+    unmatchedLetterPenalty: -1
+};

 /**
 * Does a fuzzy search to find pattern inside a string.
- * @param {*} pattern string        pattern to search for
- * @param {*} str     string        string which is being searched
+ * @param {string} pattern        pattern to search for
+ * @param {string} str            string which is being searched
+ * @param {boolean} global        whether to search for all matches or just one
 * @returns [boolean, number]       a boolean which tells if pattern was
 *                                  found or not and a search score
 */
-export function fuzzyMatch(pattern, str) {
+export function fuzzyMatch(pattern, str, global=false, weights=DEFAULT_WEIGHTS) {
    const recursionCount = 0;
    const recursionLimit = 10;
    const matches = [];
    const maxMatches = 256;

-    return fuzzyMatchRecursive(
-        pattern,
-        str,
-        0 /* patternCurIndex */,
-        0 /* strCurrIndex */,
-        null /* srcMatces */,
-        matches,
-        maxMatches,
-        0 /* nextMatch */,
-        recursionCount,
-        recursionLimit
-    );
+    if (!global) {
+        return fuzzyMatchRecursive(
+            pattern,
+            str,
+            0 /* patternCurIndex */,
+            0 /* strCurrIndex */,
+            null /* srcMatches */,
+            matches,
+            maxMatches,
+            0 /* nextMatch */,
+            recursionCount,
+            recursionLimit,
+            weights
+        );
+    }
+
+    // Return all matches
+    let foundMatch = true,
+        score,
+        idxs,
+        strCurrIndex = 0;
+    const results = [];
+
+    while (foundMatch) {
+        [foundMatch, score, idxs] = fuzzyMatchRecursive(
+            pattern,
+            str,
+            0 /* patternCurIndex */,
+            strCurrIndex,
+            null /* srcMatches */,
+            matches,
+            maxMatches,
+            0 /* nextMatch */,
+            recursionCount,
+            recursionLimit,
+            weights
+        );
+        if (foundMatch) results.push([foundMatch, score, [...idxs]]);
+        strCurrIndex = idxs[idxs.length - 1] + 1;
+    }
+    return results;
 }

 /**
@@ -65,7 +97,8 @@ function fuzzyMatchRecursive(
    maxMatches,
    nextMatch,
    recursionCount,
-    recursionLimit
+    recursionLimit,
+    weights
 ) {
    let outScore = 0;

@@ -110,7 +143,8 @@ function fuzzyMatchRecursive(
                maxMatches,
                nextMatch,
                recursionCount,
-                recursionLimit
+                recursionLimit,
+                weights
            );

            if (matched) {
@@ -134,16 +168,16 @@ function fuzzyMatchRecursive(
        outScore = 100;

        // Apply leading letter penalty
-        let penalty = LEADING_LETTER_PENALTY * matches[0];
+        let penalty = weights.leadingLetterPenalty * matches[0];
        penalty =
-            penalty < MAX_LEADING_LETTER_PENALTY ?
-                MAX_LEADING_LETTER_PENALTY :
+            penalty < weights.maxLeadingLetterPenalty ?
+                weights.maxLeadingLetterPenalty :
                penalty;
        outScore += penalty;

        // Apply unmatched penalty
        const unmatched = str.length - nextMatch;
-        outScore += UNMATCHED_LETTER_PENALTY * unmatched;
+        outScore += weights.unmatchedLetterPenalty * unmatched;

        // Apply ordering bonuses
        for (let i = 0; i < nextMatch; i++) {
@@ -152,7 +186,7 @@ function fuzzyMatchRecursive(
            if (i > 0) {
                const prevIdx = matches[i - 1];
                if (currIdx === prevIdx + 1) {
-                    outScore += SEQUENTIAL_BONUS;
+                    outScore += weights.sequentialBonus;
                }
            }

@@ -165,15 +199,15 @@ function fuzzyMatchRecursive(
                    neighbor !== neighbor.toUpperCase() &&
                    curr !== curr.toLowerCase()
                ) {
-                    outScore += CAMEL_BONUS;
+                    outScore += weights.camelBonus;
                }
                const isNeighbourSeparator = neighbor === "_" || neighbor === " ";
                if (isNeighbourSeparator) {
-                    outScore += SEPARATOR_BONUS;
+                    outScore += weights.separatorBonus;
                }
            } else {
                // First letter
-                outScore += FIRST_LETTER_BONUS;
+                outScore += weights.firstLetterBonus;
            }
        }

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

@@ -35,7 +35,8 @@ class FromBinary extends Operation {
            {
                "name": "Byte Length",
                "type": "number",
-                "value": 8
+                "value": 8,
+                "min": 1
            }
        ];
        this.checks = [
@@ -0,0 +1,121 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2021
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import {fuzzyMatch, calcMatchRanges, DEFAULT_WEIGHTS} from "../lib/FuzzyMatch.mjs";
+import Utils from "../Utils.mjs";
+
+/**
+ * Fuzzy Match operation
+ */
+class FuzzyMatch extends Operation {
+
+    /**
+     * FuzzyMatch constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Fuzzy Match";
+        this.module = "Default";
+        this.description = "Conducts a fuzzy search to find a pattern within the input based on weighted criteria.<br><br>e.g. A search for <code>dpan</code> will match on <code><b>D</b>on't <b>Pan</b>ic</code>";
+        this.infoURL = "https://wikipedia.org/wiki/Fuzzy_matching_(computer-assisted_translation)";
+        this.inputType = "string";
+        this.outputType = "html";
+        this.args = [
+            {
+                name: "Search",
+                type: "binaryString",
+                value: ""
+            },
+            {
+                name: "Sequential bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.sequentialBonus,
+                hint: "Bonus for adjacent matches"
+            },
+            {
+                name: "Separator bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.separatorBonus,
+                hint: "Bonus if match occurs after a separator"
+            },
+            {
+                name: "Camel bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.camelBonus,
+                hint: "Bonus if match is uppercase and previous is lower"
+            },
+            {
+                name: "First letter bonus",
+                type: "number",
+                value: DEFAULT_WEIGHTS.firstLetterBonus,
+                hint: "Bonus if the first letter is matched"
+            },
+            {
+                name: "Leading letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.leadingLetterPenalty,
+                hint: "Penalty applied for every letter in the input before the first match"
+            },
+            {
+                name: "Max leading letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.maxLeadingLetterPenalty,
+                hint: "Maxiumum penalty for leading letters"
+            },
+            {
+                name: "Unmatched letter penalty",
+                type: "number",
+                value: DEFAULT_WEIGHTS.unmatchedLetterPenalty
+            },
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {html}
+     */
+    run(input, args) {
+        const searchStr = args[0];
+        const weights = {
+            sequentialBonus: args[1],
+            separatorBonus: args[2],
+            camelBonus: args[3],
+            firstLetterBonus: args[4],
+            leadingLetterPenalty: args[5],
+            maxLeadingLetterPenalty: args[6],
+            unmatchedLetterPenalty: args[7]
+        };
+        const matches = fuzzyMatch(searchStr, input, true, weights);
+
+        if (!matches) {
+            return "No matches.";
+        }
+
+        let result = "", pos = 0, hlClass = "hl1";
+        matches.forEach(([matches, score, idxs]) => {
+            const matchRanges = calcMatchRanges(idxs);
+
+            matchRanges.forEach(([start, length], i) => {
+                result += Utils.escapeHtml(input.slice(pos, start));
+                if (i === 0) result += `<span class="${hlClass}">`;
+                pos = start + length;
+                result += `<b>${Utils.escapeHtml(input.slice(start, pos))}</b>`;
+            });
+            result += "</span>";
+            hlClass = hlClass === "hl1" ? "hl2" : "hl1";
+        });
+
+        result += Utils.escapeHtml(input.slice(pos, input.length));
+
+        return result;
+    }
+
+}
+
+export default FuzzyMatch;
@@ -0,0 +1,63 @@
+/**
+ * @author n1073645 [n1073645@gmail.com]
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2020
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import OperationError from "../errors/OperationError.mjs";
+import {UNITS} from "../lib/DateTime.mjs";
+
+/**
+ * Get Time operation
+ */
+class GetTime extends Operation {
+
+    /**
+     * GetTime constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Get Time";
+        this.module = "Default";
+        this.description = "Generates a timestamp showing the amount of time since the UNIX epoch (1970-01-01 00:00:00 UTC). Uses the W3C High Resolution Time API.";
+        this.infoURL = "https://wikipedia.org/wiki/Unix_time";
+        this.inputType = "string";
+        this.outputType = "number";
+        this.args = [
+            {
+                name: "Granularity",
+                type: "option",
+                value: UNITS
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {number}
+     */
+    run(input, args) {
+        const nowMs = (performance.timeOrigin + performance.now()),
+            granularity = args[0];
+
+        switch (granularity) {
+            case "Nanoseconds (ns)":
+                return Math.round(nowMs * 1000 * 1000);
+            case "Microseconds (μs)":
+                return Math.round(nowMs * 1000);
+            case "Milliseconds (ms)":
+                return Math.round(nowMs);
+            case "Seconds (s)":
+                return Math.round(nowMs / 1000);
+            default:
+                throw new OperationError("Unknown granularity value: " + granularity);
+        }
+    }
+
+}
+
+export default GetTime;
@@ -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 ||
@@ -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;
+                    }
+                }
            }


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

 import Operation from "../Operation.mjs";
 import Utils from "../Utils.mjs";
+import OperationError from "../errors/OperationError.mjs";

 /**
 * To Hexdump operation
@@ -20,7 +21,7 @@ class ToHexdump extends Operation {

        this.name = "To Hexdump";
        this.module = "Default";
-        this.description = "Creates a hexdump of the input data, displaying both the hexadecimal values of each byte and an ASCII representation alongside.";
+        this.description = "Creates a hexdump of the input data, displaying both the hexadecimal values of each byte and an ASCII representation alongside.<br><br>The 'UNIX format' argument defines which subset of printable characters are displayed in the preview column.";
        this.infoURL = "https://wikipedia.org/wiki/Hex_dump";
        this.inputType = "ArrayBuffer";
        this.outputType = "string";
@@ -28,7 +29,8 @@ class ToHexdump extends Operation {
            {
                "name": "Width",
                "type": "number",
-                "value": 16
+                "value": 16,
+                "min": 1
            },
            {
                "name": "Upper case hex",
@@ -39,6 +41,11 @@ class ToHexdump extends Operation {
                "name": "Include final length",
                "type": "boolean",
                "value": false
+            },
+            {
+                "name": "UNIX format",
+                "type": "boolean",
+                "value": false
            }
        ];
    }
@@ -50,9 +57,12 @@ class ToHexdump extends Operation {
     */
    run(input, args) {
        const data = new Uint8Array(input);
-        const [length, upperCase, includeFinalLength] = args;
+        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);
@@ -70,7 +80,9 @@ class ToHexdump extends Operation {

            output += lineNo + "  " +
                hexa.padEnd(length*(padding+1), " ") +
-                " |" + Utils.printable(Utils.byteArrayToChars(buff)).padEnd(buff.length, " ") + "|\n";
+                " |" +
+                Utils.printable(Utils.byteArrayToChars(buff), false, unixFormat).padEnd(buff.length, " ") +
+                "|\n";

            if (includeFinalLength && i+buff.length === data.length) {
                output += Utils.hex(i+buff.length, 8) + "\n";
@@ -725,7 +725,7 @@ class App {
        this.progress = 0;
        this.autoBake();

-        this.updateTitle(false, null, true);
+        this.updateTitle(true, null, true);
    }


@@ -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>

@@ -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;
            }
        }

@@ -6,7 +6,7 @@

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


 /**
@@ -102,6 +102,9 @@ import "./tests/Colossus.mjs";
 import "./tests/ParseObjectIDTimestamp.mjs";
 import "./tests/Unicode.mjs";
 import "./tests/RSA.mjs";
+import "./tests/CBOREncode.mjs";
+import "./tests/CBORDecode.mjs";
+

 // Cannot test operations that use the File type yet
 // import "./tests/SplitColourChannels.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: []
+            }
+        ]
+    }
+]);
@@ -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: []
+            }
+        ]
+    }
+]);
@@ -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": ""}
                ]
            }
@@ -64,7 +64,10 @@ TestRegister.addTests([
                        "option": "Hex",
                        "string": ""
                    },
-                    ""
+                    {
+                        "option": "Hex",
+                        "string": ""
+                    }
                ]
            }
        ]
Author	SHA1	Message	Date
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
n1474335	70cd375049	9.27.0	2021-02-12 13:54:52 +00:00
n1474335	e27e1dd42f	Updated CHANGELOG	2021-02-12 13:53:59 +00:00
n1474335	8ad18bc7db	Added 'Fuzzy Match' operation	2021-02-12 13:51:51 +00:00
n1474335	5893ac1a37	9.26.3	2021-02-12 12:12:08 +00:00
n1474335	83c3ab97f9	Merge branch 'n1073645-base64Alphabets'	2021-02-12 12:11:53 +00:00
n1474335	9b6be140fa	Merge branch 'base64Alphabets' of https://github.com/n1073645/CyberChef into n1073645-base64Alphabets	2021-02-12 12:08:56 +00:00
n1474335	a6a60392c2	9.26.2	2021-02-12 12:05:03 +00:00
n1474335	ccfa0b991e	Updated dependencies	2021-02-12 12:04:59 +00:00
n1474335	73b0e68993	Added code quality badge to README	2021-02-12 11:54:54 +00:00
n1474335	31a4eef001	9.26.1	2021-02-11 19:06:58 +00:00
n1474335	d6e2c9a6b9	Merge branch 'n1073645-HexdumpAsciiFix'	2021-02-11 19:06:47 +00:00
n1474335	e069f5db13	Tidied up hexdump UNIX format	2021-02-11 19:06:35 +00:00
n1474335	96b59cf0df	Merge branch 'HexdumpAsciiFix' of https://github.com/n1073645/CyberChef into n1073645-HexdumpAsciiFix	2021-02-11 18:59:51 +00:00
n1474335	c1e1d4b7e3	9.26.0	2021-02-11 18:50:09 +00:00
n1474335	32d869231e	Updated CHANGELOG	2021-02-11 18:50:03 +00:00
n1474335	6f95f01dda	Merge branch 'n1073645-EPOCH'	2021-02-11 18:47:59 +00:00
n1474335	61a1c44f26	Renamed 'Generate Current Epoch' to 'Get Time'. It now uses the W3C High Resolution Time API and supports microsecond granularity	2021-02-11 18:47:44 +00:00
n1474335	e6c7899569	Merge branch 'EPOCH' of https://github.com/n1073645/CyberChef into n1073645-EPOCH	2021-02-11 18:08:55 +00:00
n1073645	7526f4d7b1	Generate Epoch Time Operation Added	2020-06-01 13:47:51 +01: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
n1073645	bda36e508a	Regexes for magic for the new alphabets	2020-03-27 13:27:56 +00:00
n1073645	d2ea1273da	Merge remote-tracking branch 'upstream/master' into base64Alphabets	2020-03-27 13:09:03 +00:00
n1073645	30bc8dfbe9	UNIX Format Added for ToHexdump	2020-03-13 10:38:37 +00:00
n1073645	53a579028c	Added only ASCII flag to ToHexdump	2020-03-12 09:30:48 +00:00
n1073645	3a2580fbc2	Extra Base64 Alphabets	2020-01-22 10:35:11 +00:00