cyberchef 9.53.0 → 9.54.0

package/CHANGELOG.md

@@ -13,6 +13,9 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.54.0] - 2022-11-25
+- Added 'Rabbit' operation [@mikecat] | [#1450]
+
 ### [9.53.0] - 2022-11-25
 - Added 'AES Key Wrap' and 'AES Key Unwrap' operations [@mikecat] | [#1456]
 
@@ -336,6 +339,7 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.54.0]: https://github.com/gchq/CyberChef/releases/tag/v9.54.0
 [9.53.0]: https://github.com/gchq/CyberChef/releases/tag/v9.53.0
 [9.52.0]: https://github.com/gchq/CyberChef/releases/tag/v9.52.0
 [9.51.0]: https://github.com/gchq/CyberChef/releases/tag/v9.51.0
@@ -589,4 +593,5 @@ All major and minor version changes will be documented in this file. Details of
 [#1457]: https://github.com/gchq/CyberChef/pull/1457
 [#1466]: https://github.com/gchq/CyberChef/pull/1466
 [#1456]: https://github.com/gchq/CyberChef/pull/1456
+[#1450]: https://github.com/gchq/CyberChef/pull/1450
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "9.53.0",
+  "version": "9.54.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",

package/src/core/config/Categories.json

@@ -75,7 +75,6 @@
             "AES Decrypt",
             "Blowfish Encrypt",
             "Blowfish Decrypt",
-            "ChaCha",
             "DES Encrypt",
             "DES Decrypt",
             "Triple DES Encrypt",
@@ -86,6 +85,8 @@
             "RC2 Decrypt",
             "RC4",
             "RC4 Drop",
+            "ChaCha",
+            "Rabbit",
             "SM4 Encrypt",
             "SM4 Decrypt",
             "ROT13",

package/src/core/config/OperationConfig.json

@@ -10845,6 +10845,63 @@
             }
         ]
     },
+    "Rabbit": {
+        "module": "Ciphers",
+        "description": "Rabbit is a high-speed stream cipher introduced in 2003 and defined in RFC 4503.<br><br>The cipher uses a 128-bit key and an optional 64-bit initialization vector (IV).<br><br>big-endian: based on RFC4503 and RFC3447<br>little-endian: compatible with Crypto++",
+        "infoURL": "https://wikipedia.org/wiki/Rabbit_(cipher)",
+        "inputType": "string",
+        "outputType": "string",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": [
+                    "Hex",
+                    "UTF8",
+                    "Latin1",
+                    "Base64"
+                ]
+            },
+            {
+                "name": "IV",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": [
+                    "Hex",
+                    "UTF8",
+                    "Latin1",
+                    "Base64"
+                ]
+            },
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": [
+                    "Big",
+                    "Little"
+                ]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": [
+                    "Raw",
+                    "Hex"
+                ]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": [
+                    "Raw",
+                    "Hex"
+                ]
+            }
+        ]
+    },
     "Rail Fence Cipher Decode": {
         "module": "Ciphers",
         "description": "Decodes Strings that were created using the Rail fence Cipher provided a key and an offset",

package/src/core/config/modules/Ciphers.mjs

@@ -35,6 +35,7 @@ import RSADecrypt from "../../operations/RSADecrypt.mjs";
 import RSAEncrypt from "../../operations/RSAEncrypt.mjs";
 import RSASign from "../../operations/RSASign.mjs";
 import RSAVerify from "../../operations/RSAVerify.mjs";
+import Rabbit from "../../operations/Rabbit.mjs";
 import RailFenceCipherDecode from "../../operations/RailFenceCipherDecode.mjs";
 import RailFenceCipherEncode from "../../operations/RailFenceCipherEncode.mjs";
 import SM4Decrypt from "../../operations/SM4Decrypt.mjs";
@@ -77,6 +78,7 @@ OpModules.Ciphers = {
     "RSA Encrypt": RSAEncrypt,
     "RSA Sign": RSASign,
     "RSA Verify": RSAVerify,
+    "Rabbit": Rabbit,
     "Rail Fence Cipher Decode": RailFenceCipherDecode,
     "Rail Fence Cipher Encode": RailFenceCipherEncode,
     "SM4 Decrypt": SM4Decrypt,

package/src/core/operations/Rabbit.mjs

@@ -0,0 +1,247 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import Utils from "../Utils.mjs";
+import { toHexFast } from "../lib/Hex.mjs";
+import OperationError from "../errors/OperationError.mjs";
+
+/**
+ * Rabbit operation
+ */
+class Rabbit extends Operation {
+
+    /**
+     * Rabbit constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "Rabbit";
+        this.module = "Ciphers";
+        this.description = "Rabbit is a high-speed stream cipher introduced in 2003 and defined in RFC 4503.<br><br>The cipher uses a 128-bit key and an optional 64-bit initialization vector (IV).<br><br>big-endian: based on RFC4503 and RFC3447<br>little-endian: compatible with Crypto++";
+        this.infoURL = "https://wikipedia.org/wiki/Rabbit_(cipher)";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Key",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "IV",
+                "type": "toggleString",
+                "value": "",
+                "toggleValues": ["Hex", "UTF8", "Latin1", "Base64"]
+            },
+            {
+                "name": "Endianness",
+                "type": "option",
+                "value": ["Big", "Little"]
+            },
+            {
+                "name": "Input",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            },
+            {
+                "name": "Output",
+                "type": "option",
+                "value": ["Raw", "Hex"]
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const key = Utils.convertToByteArray(args[0].string, args[0].option),
+            iv = Utils.convertToByteArray(args[1].string, args[1].option),
+            endianness = args[2],
+            inputType = args[3],
+            outputType = args[4];
+
+        const littleEndian = endianness === "Little";
+
+        if (key.length !== 16) {
+            throw new OperationError(`Invalid key length: ${key.length} bytes (expected: 16)`);
+        }
+        if (iv.length !== 0 && iv.length !== 8) {
+            throw new OperationError(`Invalid IV length: ${iv.length} bytes (expected: 0 or 8)`);
+        }
+
+        // Inner State
+        const X = new Uint32Array(8), C = new Uint32Array(8);
+        let b = 0;
+
+        // Counter System
+        const A = [
+            0x4d34d34d, 0xd34d34d3, 0x34d34d34, 0x4d34d34d,
+            0xd34d34d3, 0x34d34d34, 0x4d34d34d, 0xd34d34d3
+        ];
+        const counterUpdate = function() {
+            for (let j = 0; j < 8; j++) {
+                const temp = C[j] + A[j] + b;
+                b = (temp / ((1 << 30) * 4)) >>> 0;
+                C[j] = temp;
+            }
+        };
+
+        // Next-State Function
+        const g = function(u, v) {
+            const uv = (u + v) >>> 0;
+            const upper = uv >>> 16, lower = uv & 0xffff;
+            const upperUpper = upper * upper;
+            const upperLower2 = 2 * upper * lower;
+            const lowerLower = lower * lower;
+            const mswTemp = upperUpper + ((upperLower2 / (1 << 16)) >>> 0);
+            const lswTemp = lowerLower + (upperLower2 & 0xffff) * (1 << 16);
+            const msw = mswTemp + ((lswTemp / ((1 << 30) * 4)) >>> 0);
+            const lsw = lswTemp >>> 0;
+            return lsw ^ msw;
+        };
+        const leftRotate = function(value, width) {
+            return (value << width) | (value >>> (32 - width));
+        };
+        const nextStateHelper1 = function(v0, v1, v2) {
+            return v0 + leftRotate(v1, 16) + leftRotate(v2, 16);
+        };
+        const nextStateHelper2 = function(v0, v1, v2) {
+            return v0 + leftRotate(v1, 8) + v2;
+        };
+        const G = new Uint32Array(8);
+        const nextState = function() {
+            for (let j = 0; j < 8; j++) {
+                G[j] = g(X[j], C[j]);
+            }
+            X[0] = nextStateHelper1(G[0], G[7], G[6]);
+            X[1] = nextStateHelper2(G[1], G[0], G[7]);
+            X[2] = nextStateHelper1(G[2], G[1], G[0]);
+            X[3] = nextStateHelper2(G[3], G[2], G[1]);
+            X[4] = nextStateHelper1(G[4], G[3], G[2]);
+            X[5] = nextStateHelper2(G[5], G[4], G[3]);
+            X[6] = nextStateHelper1(G[6], G[5], G[4]);
+            X[7] = nextStateHelper2(G[7], G[6], G[5]);
+        };
+
+        // Key Setup Scheme
+        const K = new Uint16Array(8);
+        if (littleEndian) {
+            for (let i = 0; i < 8; i++) {
+                K[i] = (key[1 + 2 * i] << 8) | key[2 * i];
+            }
+        } else {
+            for (let i = 0; i < 8; i++) {
+                K[i] = (key[14 - 2 * i] << 8) | key[15 - 2 * i];
+            }
+        }
+        for (let j = 0; j < 8; j++) {
+            if (j % 2 === 0) {
+                X[j] = (K[(j + 1) % 8] << 16) | K[j];
+                C[j] = (K[(j + 4) % 8] << 16) | K[(j + 5) % 8];
+            } else {
+                X[j] = (K[(j + 5) % 8] << 16) | K[(j + 4) % 8];
+                C[j] = (K[j] << 16) | K[(j + 1) % 8];
+            }
+        }
+        for (let i = 0; i < 4; i++) {
+            counterUpdate();
+            nextState();
+        }
+        for (let j = 0; j < 8; j++) {
+            C[j] = C[j] ^ X[(j + 4) % 8];
+        }
+
+        // IV Setup Scheme
+        if (iv.length === 8) {
+            const getIVValue = function(a, b, c, d) {
+                if (littleEndian) {
+                    return (iv[a] << 24) | (iv[b] << 16) |
+                        (iv[c] << 8) | iv[d];
+                } else {
+                    return (iv[7 - a] << 24) | (iv[7 - b] << 16) |
+                        (iv[7 - c] << 8) | iv[7 - d];
+                }
+            };
+            C[0] = C[0] ^ getIVValue(3, 2, 1, 0);
+            C[1] = C[1] ^ getIVValue(7, 6, 3, 2);
+            C[2] = C[2] ^ getIVValue(7, 6, 5, 4);
+            C[3] = C[3] ^ getIVValue(5, 4, 1, 0);
+            C[4] = C[4] ^ getIVValue(3, 2, 1, 0);
+            C[5] = C[5] ^ getIVValue(7, 6, 3, 2);
+            C[6] = C[6] ^ getIVValue(7, 6, 5, 4);
+            C[7] = C[7] ^ getIVValue(5, 4, 1, 0);
+            for (let i = 0; i < 4; i++) {
+                counterUpdate();
+                nextState();
+            }
+        }
+
+        // Extraction Scheme
+        const S = new Uint8Array(16);
+        const extract = function() {
+            let pos = 0;
+            const addPart = function(value) {
+                S[pos++] = value >>> 8;
+                S[pos++] = value & 0xff;
+            };
+            counterUpdate();
+            nextState();
+            addPart((X[6] >>> 16) ^ (X[1] & 0xffff));
+            addPart((X[6] & 0xffff) ^ (X[3] >>> 16));
+            addPart((X[4] >>> 16) ^ (X[7] & 0xffff));
+            addPart((X[4] & 0xffff) ^ (X[1] >>> 16));
+            addPart((X[2] >>> 16) ^ (X[5] & 0xffff));
+            addPart((X[2] & 0xffff) ^ (X[7] >>> 16));
+            addPart((X[0] >>> 16) ^ (X[3] & 0xffff));
+            addPart((X[0] & 0xffff) ^ (X[5] >>> 16));
+            if (littleEndian) {
+                for (let i = 0, j = S.length - 1; i < j;) {
+                    const temp = S[i];
+                    S[i] = S[j];
+                    S[j] = temp;
+                    i++;
+                    j--;
+                }
+            }
+        };
+
+        const data = Utils.convertToByteString(input, inputType);
+        const result = new Uint8Array(data.length);
+        for (let i = 0; i <= data.length - 16; i += 16) {
+            extract();
+            for (let j = 0; j < 16; j++) {
+                result[i + j] = data.charCodeAt(i + j) ^ S[j];
+            }
+        }
+        if (data.length % 16 !== 0) {
+            const offset = data.length - data.length % 16;
+            const length = data.length - offset;
+            extract();
+            if (littleEndian) {
+                for (let j = 0; j < length; j++) {
+                    result[offset + j] = data.charCodeAt(offset + j) ^ S[j];
+                }
+            } else {
+                for (let j = 0; j < length; j++) {
+                    result[offset + j] = data.charCodeAt(offset + j) ^ S[16 - length + j];
+                }
+            }
+        }
+        if (outputType === "Hex") {
+            return toHexFast(result);
+        }
+        return Utils.byteArrayToChars(result);
+    }
+
+}
+
+export default Rabbit;

package/src/core/operations/index.mjs

@@ -274,6 +274,7 @@ import RSADecrypt from "./RSADecrypt.mjs";
 import RSAEncrypt from "./RSAEncrypt.mjs";
 import RSASign from "./RSASign.mjs";
 import RSAVerify from "./RSAVerify.mjs";
+import Rabbit from "./Rabbit.mjs";
 import RailFenceCipherDecode from "./RailFenceCipherDecode.mjs";
 import RailFenceCipherEncode from "./RailFenceCipherEncode.mjs";
 import RandomizeColourPalette from "./RandomizeColourPalette.mjs";
@@ -670,6 +671,7 @@ export {
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    Rabbit,
     RailFenceCipherDecode,
     RailFenceCipherEncode,
     RandomizeColourPalette,

package/src/node/index.mjs

@@ -275,6 +275,7 @@ import {
     RSAEncrypt as core_RSAEncrypt,
     RSASign as core_RSASign,
     RSAVerify as core_RSAVerify,
+    Rabbit as core_Rabbit,
     RailFenceCipherDecode as core_RailFenceCipherDecode,
     RailFenceCipherEncode as core_RailFenceCipherEncode,
     RandomizeColourPalette as core_RandomizeColourPalette,
@@ -671,6 +672,7 @@ function generateChef() {
         "RSAEncrypt": _wrap(core_RSAEncrypt),
         "RSASign": _wrap(core_RSASign),
         "RSAVerify": _wrap(core_RSAVerify),
+        "rabbit": _wrap(core_Rabbit),
         "railFenceCipherDecode": _wrap(core_RailFenceCipherDecode),
         "railFenceCipherEncode": _wrap(core_RailFenceCipherEncode),
         "randomizeColourPalette": _wrap(core_RandomizeColourPalette),
@@ -1084,6 +1086,7 @@ const RSADecrypt = chef.RSADecrypt;
 const RSAEncrypt = chef.RSAEncrypt;
 const RSASign = chef.RSASign;
 const RSAVerify = chef.RSAVerify;
+const rabbit = chef.rabbit;
 const railFenceCipherDecode = chef.railFenceCipherDecode;
 const railFenceCipherEncode = chef.railFenceCipherEncode;
 const randomizeColourPalette = chef.randomizeColourPalette;
@@ -1482,6 +1485,7 @@ const operations = [
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    rabbit,
     railFenceCipherDecode,
     railFenceCipherEncode,
     randomizeColourPalette,
@@ -1884,6 +1888,7 @@ export {
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    rabbit,
     railFenceCipherDecode,
     railFenceCipherEncode,
     randomizeColourPalette,

package/tests/operations/index.mjs

@@ -129,6 +129,7 @@ import "./tests/Shuffle.mjs";
 import "./tests/FletcherChecksum.mjs";
 import "./tests/CMAC.mjs";
 import "./tests/AESKeyWrap.mjs";
+import "./tests/Rabbit.mjs";
 
 // Cannot test operations that use the File type yet
 // import "./tests/SplitColourChannels.mjs";

package/tests/operations/tests/Rabbit.mjs

@@ -0,0 +1,177 @@
+/**
+ * @author mikecat
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "Rabbit: RFC Test vector, without IV 1",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "b15754f036a5d6ecf56b45261c4af70288e8d815c59c0c397b696c4789c68aa7f416a1c3700cd451da68d1881673d696",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: RFC Test vector, without IV 2",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "3d2df3c83ef627a1e97fc38487e2519cf576cd61f4405b8896bf53aa8554fc19e5547473fbdb43508ae53b20204d4c5e",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "912813292e3d36fe3bfc62f1dc51c3ac"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: RFC Test vector, without IV 3",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "0cb10dcda041cdac32eb5cfd02d0609b95fc9fca0f17015a7b7092114cff3ead9649e5de8bfc7f3f924147ad3a947428",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "8395741587e0c733e9e9ab01c09b0043"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: RFC Test vector, with IV 1",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "c6a7275ef85495d87ccd5d376705b7ed5f29a6ac04f5efd47b8f293270dc4a8d2ade822b29de6c1ee52bdb8a47bf8f66",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": "0000000000000000"},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: RFC Test vector, with IV 2",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "1fcd4eb9580012e2e0dccc9222017d6da75f4e10d12125017b2499ffed936f2eebc112c393e738392356bdd012029ba7",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": "c373f575c1267e59"},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: RFC Test vector, with IV 3",
+        input: "000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
+        expectedOutput: "445ad8c805858dbf70b6af23a151104d96c8f27947f42c5baeae67c6acc35b039fcbfc895fa71c17313df034f01551cb",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": "a6eb561ad2f41727"},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: generated stream should be XORed with the input",
+        input: "cedda96c054e3ddd93da7ed05e2a4b7bdb0c00fe214f03502e2708b2c2bfc77aa2311b0b9af8aa78d119f92b26db0a6b",
+        expectedOutput: "7f8afd9c33ebeb3166b13bf64260bc7953e4d8ebe4d30f69554e64f54b794ddd5627bac8eaf47e290b7128a330a8dcfd",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: least significant bits should be used for the last block",
+        input: "0000000000000000",
+        expectedOutput: "f56b45261c4af702",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: invalid key length",
+        input: "",
+        expectedOutput: "Invalid key length: 8 bytes (expected: 16)",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "0000000000000000"},
+                    {"option": "Hex", "string": ""},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Rabbit: invalid IV length",
+        input: "",
+        expectedOutput: "Invalid IV length: 4 bytes (expected: 0 or 8)",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "00000000000000000000000000000000"},
+                    {"option": "Hex", "string": "00000000"},
+                    "Big", "Hex", "Hex"
+                ]
+            }
+        ]
+    },
+    {
+	// this testcase is taken from the first example on Crypto++ Wiki
+	// https://www.cryptopp.com/wiki/Rabbit
+        name: "Rabbit: little-endian mode (Crypto++ compatible)",
+        input: "Rabbit stream cipher test",
+        expectedOutput: "1ae2d4edcf9b6063b00fd6fda0b223aded157e77031cf0440b",
+        recipeConfig: [
+            {
+                "op": "Rabbit",
+                "args": [
+                    {"option": "Hex", "string": "23c2731e8b5469fd8dabb5bc592a0f3a"},
+                    {"option": "Hex", "string": "712906405ef03201"},
+                    "Little", "Raw", "Hex"
+                ]
+            }
+        ]
+    },
+]);