Merge d525a0cc31 into 18159ce806

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "cyberchef",
-  "version": "10.18.4",
+  "version": "10.18.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "cyberchef",
-      "version": "10.18.4",
+      "version": "10.18.6",
       "hasInstallScript": true,
       "license": "Apache-2.0",
       "dependencies": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "10.18.4",
+  "version": "10.18.6",
   "description": "The Cyber Swiss Army Knife for encryption, encoding, compression and data analysis.",
   "author": "n1474335 <n1474335@gmail.com>",
   "homepage": "https://gchq.github.io/CyberChef",

src/core/operations/GOSTDecrypt.mjs

@@ -55,22 +55,19 @@ class GOSTDecrypt extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -100,14 +97,30 @@ class GOSTDecrypt extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ivObj, inputType, outputType, version, length, sBox, blockMode, keyMeshing, padding] = args;
+        const [keyObj, ivObj, inputType, outputType, version, sBox, blockMode, keyMeshing, padding] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

src/core/operations/GOSTEncrypt.mjs

@@ -55,22 +55,19 @@ class GOSTEncrypt extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -100,14 +97,30 @@ class GOSTEncrypt extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ivObj, inputType, outputType, version, length, sBox, blockMode, keyMeshing, padding] = args;
+        const [keyObj, ivObj, inputType, outputType, version, sBox, blockMode, keyMeshing, padding] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

src/core/operations/GOSTKeyUnwrap.mjs

@@ -55,22 +55,19 @@ class GOSTKeyUnwrap extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -90,14 +87,30 @@ class GOSTKeyUnwrap extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ukmObj, inputType, outputType, version, length, sBox, keyWrapping] = args;
+        const [keyObj, ukmObj, inputType, outputType, version, sBox, keyWrapping] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const ukm = toHexFast(Utils.convertToByteArray(ukmObj.string, ukmObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

src/core/operations/GOSTKeyWrap.mjs

@@ -55,22 +55,19 @@ class GOSTKeyWrap extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -90,14 +87,30 @@ class GOSTKeyWrap extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ukmObj, inputType, outputType, version, length, sBox, keyWrapping] = args;
+        const [keyObj, ukmObj, inputType, outputType, version, sBox, keyWrapping] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const ukm = toHexFast(Utils.convertToByteArray(ukmObj.string, ukmObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

src/core/operations/GOSTSign.mjs

@@ -55,22 +55,19 @@ class GOSTSign extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -93,14 +90,30 @@ class GOSTSign extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ivObj, inputType, outputType, version, length, sBox, macLength] = args;
+        const [keyObj, ivObj, inputType, outputType, version, sBox, macLength] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

src/core/operations/GOSTVerify.mjs

@@ -56,22 +56,19 @@ class GOSTVerify extends Operation {
                 type: "argSelector",
                 value: [
                     {
-                        name: "GOST 28147 (Magma, 1989)",
-                        off: [5],
+                        name: "GOST 28147 (1989)",
                         on: [6]
                     },
+                    {
+                        name: "GOST R 34.12 (Magma, 2015)",
+                        off: [5]
+                    },
                     {
                         name: "GOST R 34.12 (Kuznyechik, 2015)",
-                        on: [5],
-                        off: [6]
+                        off: [5]
                     }
                 ]
             },
-            {
-                name: "Block length",
-                type: "option",
-                value: ["64", "128"]
-            },
             {
                 name: "sBox",
                 type: "option",
@@ -86,15 +83,31 @@ class GOSTVerify extends Operation {
      * @returns {string}
      */
     async run(input, args) {
-        const [keyObj, ivObj, macObj, inputType, version, length, sBox] = args;
+        const [keyObj, ivObj, macObj, inputType, version, sBox] = args;
 
         const key = toHexFast(Utils.convertToByteArray(keyObj.string, keyObj.option));
         const iv = toHexFast(Utils.convertToByteArray(ivObj.string, ivObj.option));
         const mac = toHexFast(Utils.convertToByteArray(macObj.string, macObj.option));
         input = inputType === "Hex" ? input : toHexFast(Utils.strToArrayBuffer(input));
 
-        const versionNum = version === "GOST 28147 (Magma, 1989)" ? 1989 : 2015;
-        const blockLength = versionNum === 1989 ? 64 : parseInt(length, 10);
+        let blockLength, versionNum;
+        switch (version) {
+            case "GOST 28147 (1989)":
+                versionNum = 1989;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Magma, 2015)":
+                versionNum = 2015;
+                blockLength = 64;
+                break;
+            case "GOST R 34.12 (Kuznyechik, 2015)":
+                versionNum = 2015;
+                blockLength = 128;
+                break;
+            default:
+                throw new OperationError(`Unknown algorithm version: ${version}`);
+        }
+
         const sBoxVal = versionNum === 1989 ? sBox : null;
 
         const algorithm = {

tests/browser/02_ops.js

@@ -430,7 +430,7 @@ function bakeOp(browser, opName, input, args=[]) {
  */
 function testOp(browser, opName, input, output, args=[]) {
     bakeOp(browser, opName, input, args);
-    utils.expectOutput(browser, output);
+    utils.expectOutput(browser, output, true);
 }
 
 /** @function

tests/browser/browserUtils.js

@@ -41,6 +41,7 @@ function setInput(browser, input, type=true) {
         }, [input]);
         browser.pause(100);
     }
+    expectInput(browser, input);
 }
 
 /** @function
@@ -49,6 +50,11 @@ function setInput(browser, input, type=true) {
  * @param {Browser} browser - Nightwatch client
  */
 function bake(browser) {
+    browser
+        // Ensure we're not currently busy
+        .waitForElementNotVisible("#output-loader", 5000)
+        .expect.element("#bake span").text.to.equal("BAKE!");
+
     browser
         .click("#bake")
         .waitForElementNotVisible("#stale-indicator", 5000)
@@ -162,7 +168,6 @@ function loadRecipe(browser, opName, input, args) {
         throw new Error("Invalid operation type. Must be string or array of strings. Received: " + typeof(opName));
     }
 
-    clear(browser);
     setInput(browser, input, false);
     browser
         .urlHash("recipe=" + recipeConfig)
@@ -174,8 +179,18 @@ function loadRecipe(browser, opName, input, args) {
  *
  * @param {Browser} browser - Nightwatch client
  * @param {string|RegExp} expected - The expected output value
+ * @param {boolean} [waitNotNull=false] - Wait for the output to not be empty before testing the value
  */
-function expectOutput(browser, expected) {
+function expectOutput(browser, expected, waitNotNull=false) {
+    if (waitNotNull && expected !== "") {
+        browser.waitUntil(async function() {
+            const output = await this.execute(function() {
+                return window.app.manager.output.outputEditorView.state.doc.toString();
+            });
+            return output.length;
+        }, 1000);
+    }
+
     browser.execute(expected => {
         return window.app.manager.output.outputEditorView.state.doc.toString();
     }, [expected], function({value}) {
@@ -187,6 +202,24 @@ function expectOutput(browser, expected) {
     });
 }
 
+/** @function
+ * Tests whether the input matches a given value
+ *
+ * @param {Browser} browser - Nightwatch client
+ * @param {string|RegExp} expected - The expected input value
+ */
+function expectInput(browser, expected) {
+    browser.execute(expected => {
+        return window.app.manager.input.inputEditorView.state.doc.toString();
+    }, [expected], function({value}) {
+        if (expected instanceof RegExp) {
+            browser.expect(value).match(expected);
+        } else {
+            browser.expect(value).to.be.equal(expected);
+        }
+    });
+}
+
 /** @function
  * Uploads a file using the #open-file input
  *
@@ -246,6 +279,7 @@ module.exports = {
     paste: paste,
     loadRecipe: loadRecipe,
     expectOutput: expectOutput,
+    expectInput: expectInput,
     uploadFile: uploadFile,
     uploadFolder: uploadFolder
 };

tests/operations/tests/GOST.mjs

@@ -14,7 +14,7 @@ import TestRegister from "../../lib/TestRegister.mjs";
 
 TestRegister.addTests([
     {
-        name: "GOST Encrypt: Magma",
+        name: "GOST Encrypt: 1989",
         input: "Hello, World!",
         expectedOutput: "f124ac5c0853870906dbaf9b56",
         recipeConfig: [
@@ -25,8 +25,7 @@ TestRegister.addTests([
                     { "option": "Hex", "string": "0011223344556677" },
                     "Raw",
                     "Hex",
-                    "GOST 28147 (Magma, 1989)",
-                    "64",
+                    "GOST 28147 (1989)",
                     "E-SC",
                     "OFB",
                     "CP",
@@ -48,7 +47,6 @@ TestRegister.addTests([
                     "Raw",
                     "Hex",
                     "GOST R 34.12 (Kuznyechik, 2015)",
-                    "128",
                     "E-SC",
                     "CBC",
                     "CP",
@@ -58,7 +56,7 @@ TestRegister.addTests([
         ],
     },
     {
-        name: "GOST Decrypt: Magma",
+        name: "GOST Decrypt: 1989",
         input: "f124ac5c0853870906dbaf9b56",
         expectedOutput: "Hello, World!",
         recipeConfig: [
@@ -69,8 +67,7 @@ TestRegister.addTests([
                     { "option": "Hex", "string": "0011223344556677" },
                     "Hex",
                     "Raw",
-                    "GOST 28147 (Magma, 1989)",
-                    "128",
+                    "GOST 28147 (1989)",
                     "E-SC",
                     "OFB",
                     "CP",
@@ -92,7 +89,6 @@ TestRegister.addTests([
                     "Hex",
                     "Raw",
                     "GOST R 34.12 (Kuznyechik, 2015)",
-                    "128",
                     "E-TEST",
                     "CBC",
                     "CP",
@@ -113,8 +109,7 @@ TestRegister.addTests([
                     { "option": "Hex", "string": "0011223344556677" },
                     "Raw",
                     "Hex",
-                    "GOST 28147 (Magma, 1989)",
-                    "64",
+                    "GOST 28147 (1989)",
                     "E-C",
                     48
                 ]
@@ -134,7 +129,6 @@ TestRegister.addTests([
                     { "option": "Hex", "string": "42b77fb3d6f6bf04" },
                     "Raw",
                     "GOST R 34.12 (Kuznyechik, 2015)",
-                    "128",
                     "E-TEST"
                 ]
             }
@@ -152,8 +146,7 @@ TestRegister.addTests([
                     { "option": "Hex", "string": "0011223344556677" },
                     "Raw",
                     "Hex",
-                    "GOST R 34.12 (Kuznyechik, 2015)",
-                    "64",
+                    "GOST R 34.12 (Magma, 2015)",
                     "E-TEST",
                     "CP"
                 ]
@@ -172,8 +165,7 @@ TestRegister.addTests([
                     { "option": "Latin1", "string": "00112233" },
                     "Hex",
                     "Raw",
-                    "GOST 28147 (Magma, 1989)",
-                    "64",
+                    "GOST 28147 (1989)",
                     "E-Z",
                     "CP"
                 ]

webpack.config.js

@@ -1,24 +1,25 @@
+const path = require("path");
+
 const webpack = require("webpack");
 const MiniCssExtractPlugin = require("mini-css-extract-plugin");
 const CopyWebpackPlugin = require("copy-webpack-plugin");
 const { ModifySourcePlugin } = require("modify-source-webpack-plugin");
-const path = require("path");
 
 /**
  * Webpack configuration details for use with Grunt.
  *
  * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2017
+ * @copyright Crown Copyright 2023
  * @license Apache-2.0
  */
 
 const banner = `/**
  * CyberChef - The Cyber Swiss Army Knife
  *
- * @copyright Crown Copyright 2016
+ * @copyright Crown Copyright 2023
  * @license Apache-2.0
  *
- *   Copyright 2016 Crown Copyright
+ *   Copyright 2023 Crown Copyright
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.