cyberchef 9.53.0 → 9.55.0

package/CHANGELOG.md

@@ -13,6 +13,12 @@ All major and minor version changes will be documented in this file. Details of
 
 ## Details
 
+### [9.55.0] - 2022-12-09
+- Added 'AMF Encode' and 'AMF Decode' operations [@n1474335] | [760eff4]
+
+### [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 +342,8 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[9.55.0]: https://github.com/gchq/CyberChef/releases/tag/v9.55.0
+[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
@@ -488,6 +496,7 @@ All major and minor version changes will be documented in this file. Details of
 [dd18e52]: https://github.com/gchq/CyberChef/commit/dd18e529939078b89867297b181a584e8b2cc7da
 [a895d1d]: https://github.com/gchq/CyberChef/commit/a895d1d82a2f92d440a0c5eca2bc7c898107b737
 [31a7f83]: https://github.com/gchq/CyberChef/commit/31a7f83b82e78927f89689f323fcb9185144d6ff
+[760eff4]: https://github.com/gchq/CyberChef/commit/760eff49b5307aaa3104c5e5b437ffe62299acd1
 
 [#95]: https://github.com/gchq/CyberChef/pull/299
 [#173]: https://github.com/gchq/CyberChef/pull/173
@@ -589,4 +598,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.55.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",
@@ -86,6 +86,7 @@
     "worker-loader": "^3.0.8"
   },
   "dependencies": {
+    "@astronautlabs/amf": "^0.0.6",
     "@babel/polyfill": "^7.12.1",
     "@blu3r4y/lzma": "^2.3.3",
     "arrive": "^2.4.1",
@@ -151,6 +152,7 @@
     "process": "^0.11.10",
     "protobufjs": "^6.11.3",
     "qr-image": "^3.2.0",
+    "reflect-metadata": "^0.1.13",
     "scryptsy": "^2.1.0",
     "snackbarjs": "^1.1.0",
     "sortablejs": "^1.15.0",

package/src/core/config/Categories.json

@@ -46,6 +46,8 @@
             "From Quoted Printable",
             "To Punycode",
             "From Punycode",
+            "AMF Encode",
+            "AMF Decode",
             "To Hex Content",
             "From Hex Content",
             "PEM to Hex",
@@ -75,7 +77,6 @@
             "AES Decrypt",
             "Blowfish Encrypt",
             "Blowfish Decrypt",
-            "ChaCha",
             "DES Encrypt",
             "DES Decrypt",
             "Triple DES Encrypt",
@@ -86,6 +87,8 @@
             "RC2 Decrypt",
             "RC4",
             "RC4 Drop",
+            "ChaCha",
+            "Rabbit",
             "SM4 Encrypt",
             "SM4 Decrypt",
             "ROT13",

package/src/core/config/OperationConfig.json

@@ -446,6 +446,46 @@
             }
         ]
     },
+    "AMF Decode": {
+        "module": "Encodings",
+        "description": "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.",
+        "infoURL": "https://wikipedia.org/wiki/Action_Message_Format",
+        "inputType": "ArrayBuffer",
+        "outputType": "JSON",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Format",
+                "type": "option",
+                "value": [
+                    "AMF0",
+                    "AMF3"
+                ],
+                "defaultIndex": 1
+            }
+        ]
+    },
+    "AMF Encode": {
+        "module": "Encodings",
+        "description": "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.",
+        "infoURL": "https://wikipedia.org/wiki/Action_Message_Format",
+        "inputType": "JSON",
+        "outputType": "ArrayBuffer",
+        "flowControl": false,
+        "manualBake": false,
+        "args": [
+            {
+                "name": "Format",
+                "type": "option",
+                "value": [
+                    "AMF0",
+                    "AMF3"
+                ],
+                "defaultIndex": 1
+            }
+        ]
+    },
     "AND": {
         "module": "Default",
         "description": "AND the input with the given key.<br>e.g. <code>fe023da5</code>",
@@ -10845,6 +10885,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/config/modules/Encodings.mjs

@@ -5,6 +5,8 @@
 * @copyright Crown Copyright 2022
 * @license Apache-2.0
 */
+import AMFDecode from "../../operations/AMFDecode.mjs";
+import AMFEncode from "../../operations/AMFEncode.mjs";
 import CitrixCTX1Decode from "../../operations/CitrixCTX1Decode.mjs";
 import CitrixCTX1Encode from "../../operations/CitrixCTX1Encode.mjs";
 import DecodeText from "../../operations/DecodeText.mjs";
@@ -19,6 +21,8 @@ import ToPunycode from "../../operations/ToPunycode.mjs";
 const OpModules = typeof self === "undefined" ? {} : self.OpModules || {};
 
 OpModules.Encodings = {
+    "AMF Decode": AMFDecode,
+    "AMF Encode": AMFEncode,
     "Citrix CTX1 Decode": CitrixCTX1Decode,
     "Citrix CTX1 Encode": CitrixCTX1Encode,
     "Decode text": DecodeText,

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

@@ -9,6 +9,7 @@
 */
 import CiphersModule from "./Ciphers.mjs";
 import DefaultModule from "./Default.mjs";
+import EncodingsModule from "./Encodings.mjs";
 import ImageModule from "./Image.mjs";
 import CryptoModule from "./Crypto.mjs";
 import SerialiseModule from "./Serialise.mjs";
@@ -16,7 +17,6 @@ import HashingModule from "./Hashing.mjs";
 import BletchleyModule from "./Bletchley.mjs";
 import CompressionModule from "./Compression.mjs";
 import CodeModule from "./Code.mjs";
-import EncodingsModule from "./Encodings.mjs";
 import DiffModule from "./Diff.mjs";
 import ShellcodeModule from "./Shellcode.mjs";
 import ChartsModule from "./Charts.mjs";
@@ -35,6 +35,7 @@ Object.assign(
     OpModules,
     CiphersModule,
     DefaultModule,
+    EncodingsModule,
     ImageModule,
     CryptoModule,
     SerialiseModule,
@@ -42,7 +43,6 @@ Object.assign(
     BletchleyModule,
     CompressionModule,
     CodeModule,
-    EncodingsModule,
     DiffModule,
     ShellcodeModule,
     ChartsModule,

package/src/core/operations/AMFDecode.mjs

@@ -0,0 +1,52 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import "reflect-metadata"; // Required as a shim for the amf library
+import { AMF0, AMF3 } from "@astronautlabs/amf";
+
+/**
+ * AMF Decode operation
+ */
+class AMFDecode extends Operation {
+
+    /**
+     * AMFDecode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "AMF Decode";
+        this.module = "Encodings";
+        this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.";
+        this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "JSON";
+        this.args = [
+            {
+                name: "Format",
+                type: "option",
+                value: ["AMF0", "AMF3"],
+                defaultIndex: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {JSON}
+     */
+    run(input, args) {
+        const [format] = args;
+        const handler = format === "AMF0" ? AMF0 : AMF3;
+        const encoded = new Uint8Array(input);
+        return handler.Value.deserialize(encoded);
+    }
+
+}
+
+export default AMFDecode;

package/src/core/operations/AMFEncode.mjs

@@ -0,0 +1,52 @@
+/**
+ * @author n1474335 [n1474335@gmail.com]
+ * @copyright Crown Copyright 2022
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation.mjs";
+import "reflect-metadata"; // Required as a shim for the amf library
+import { AMF0, AMF3 } from "@astronautlabs/amf";
+
+/**
+ * AMF Encode operation
+ */
+class AMFEncode extends Operation {
+
+    /**
+     * AMFEncode constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "AMF Encode";
+        this.module = "Encodings";
+        this.description = "Action Message Format (AMF) is a binary format used to serialize object graphs such as ActionScript objects and XML, or send messages between an Adobe Flash client and a remote service, usually a Flash Media Server or third party alternatives.";
+        this.infoURL = "https://wikipedia.org/wiki/Action_Message_Format";
+        this.inputType = "JSON";
+        this.outputType = "ArrayBuffer";
+        this.args = [
+            {
+                name: "Format",
+                type: "option",
+                value: ["AMF0", "AMF3"],
+                defaultIndex: 1
+            }
+        ];
+    }
+
+    /**
+     * @param {JSON} input
+     * @param {Object[]} args
+     * @returns {ArrayBuffer}
+     */
+    run(input, args) {
+        const [format] = args;
+        const handler = format === "AMF0" ? AMF0 : AMF3;
+        const output = handler.Value.any(input).serialize();
+        return output.buffer;
+    }
+
+}
+
+export default AMFEncode;

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

@@ -12,6 +12,8 @@ import AESDecrypt from "./AESDecrypt.mjs";
 import AESEncrypt from "./AESEncrypt.mjs";
 import AESKeyUnwrap from "./AESKeyUnwrap.mjs";
 import AESKeyWrap from "./AESKeyWrap.mjs";
+import AMFDecode from "./AMFDecode.mjs";
+import AMFEncode from "./AMFEncode.mjs";
 import AND from "./AND.mjs";
 import AddLineNumbers from "./AddLineNumbers.mjs";
 import AddTextToImage from "./AddTextToImage.mjs";
@@ -274,6 +276,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";
@@ -408,6 +411,8 @@ export {
     AESEncrypt,
     AESKeyUnwrap,
     AESKeyWrap,
+    AMFDecode,
+    AMFEncode,
     AND,
     AddLineNumbers,
     AddTextToImage,
@@ -670,6 +675,7 @@ export {
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    Rabbit,
     RailFenceCipherDecode,
     RailFenceCipherEncode,
     RandomizeColourPalette,

package/src/node/index.mjs

@@ -22,6 +22,8 @@ import {
     AESEncrypt as core_AESEncrypt,
     AESKeyUnwrap as core_AESKeyUnwrap,
     AESKeyWrap as core_AESKeyWrap,
+    AMFDecode as core_AMFDecode,
+    AMFEncode as core_AMFEncode,
     AND as core_AND,
     AddLineNumbers as core_AddLineNumbers,
     AddTextToImage as core_AddTextToImage,
@@ -275,6 +277,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,
@@ -418,6 +421,8 @@ function generateChef() {
         "AESEncrypt": _wrap(core_AESEncrypt),
         "AESKeyUnwrap": _wrap(core_AESKeyUnwrap),
         "AESKeyWrap": _wrap(core_AESKeyWrap),
+        "AMFDecode": _wrap(core_AMFDecode),
+        "AMFEncode": _wrap(core_AMFEncode),
         "AND": _wrap(core_AND),
         "addLineNumbers": _wrap(core_AddLineNumbers),
         "addTextToImage": _wrap(core_AddTextToImage),
@@ -671,6 +676,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),
@@ -822,6 +828,8 @@ const AESDecrypt = chef.AESDecrypt;
 const AESEncrypt = chef.AESEncrypt;
 const AESKeyUnwrap = chef.AESKeyUnwrap;
 const AESKeyWrap = chef.AESKeyWrap;
+const AMFDecode = chef.AMFDecode;
+const AMFEncode = chef.AMFEncode;
 const AND = chef.AND;
 const addLineNumbers = chef.addLineNumbers;
 const addTextToImage = chef.addTextToImage;
@@ -1084,6 +1092,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;
@@ -1220,6 +1229,8 @@ const operations = [
     AESEncrypt,
     AESKeyUnwrap,
     AESKeyWrap,
+    AMFDecode,
+    AMFEncode,
     AND,
     addLineNumbers,
     addTextToImage,
@@ -1482,6 +1493,7 @@ const operations = [
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    rabbit,
     railFenceCipherDecode,
     railFenceCipherEncode,
     randomizeColourPalette,
@@ -1622,6 +1634,8 @@ export {
     AESEncrypt,
     AESKeyUnwrap,
     AESKeyWrap,
+    AMFDecode,
+    AMFEncode,
     AND,
     addLineNumbers,
     addTextToImage,
@@ -1884,6 +1898,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"
+                ]
+            }
+        ]
+    },
+]);