cyberchef 9.52.1 → 9.54.0

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

@@ -10,6 +10,8 @@ import A1Z26CipherEncode from "./A1Z26CipherEncode.mjs";
 import ADD from "./ADD.mjs";
 import AESDecrypt from "./AESDecrypt.mjs";
 import AESEncrypt from "./AESEncrypt.mjs";
+import AESKeyUnwrap from "./AESKeyUnwrap.mjs";
+import AESKeyWrap from "./AESKeyWrap.mjs";
 import AND from "./AND.mjs";
 import AddLineNumbers from "./AddLineNumbers.mjs";
 import AddTextToImage from "./AddTextToImage.mjs";
@@ -272,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";
@@ -404,6 +407,8 @@ export {
     ADD,
     AESDecrypt,
     AESEncrypt,
+    AESKeyUnwrap,
+    AESKeyWrap,
     AND,
     AddLineNumbers,
     AddTextToImage,
@@ -666,6 +671,7 @@ export {
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    Rabbit,
     RailFenceCipherDecode,
     RailFenceCipherEncode,
     RandomizeColourPalette,

package/src/node/index.mjs

@@ -20,6 +20,8 @@ import {
     ADD as core_ADD,
     AESDecrypt as core_AESDecrypt,
     AESEncrypt as core_AESEncrypt,
+    AESKeyUnwrap as core_AESKeyUnwrap,
+    AESKeyWrap as core_AESKeyWrap,
     AND as core_AND,
     AddLineNumbers as core_AddLineNumbers,
     AddTextToImage as core_AddTextToImage,
@@ -273,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,
@@ -414,6 +417,8 @@ function generateChef() {
         "ADD": _wrap(core_ADD),
         "AESDecrypt": _wrap(core_AESDecrypt),
         "AESEncrypt": _wrap(core_AESEncrypt),
+        "AESKeyUnwrap": _wrap(core_AESKeyUnwrap),
+        "AESKeyWrap": _wrap(core_AESKeyWrap),
         "AND": _wrap(core_AND),
         "addLineNumbers": _wrap(core_AddLineNumbers),
         "addTextToImage": _wrap(core_AddTextToImage),
@@ -667,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),
@@ -816,6 +822,8 @@ const A1Z26CipherEncode = chef.A1Z26CipherEncode;
 const ADD = chef.ADD;
 const AESDecrypt = chef.AESDecrypt;
 const AESEncrypt = chef.AESEncrypt;
+const AESKeyUnwrap = chef.AESKeyUnwrap;
+const AESKeyWrap = chef.AESKeyWrap;
 const AND = chef.AND;
 const addLineNumbers = chef.addLineNumbers;
 const addTextToImage = chef.addTextToImage;
@@ -1078,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;
@@ -1212,6 +1221,8 @@ const operations = [
     ADD,
     AESDecrypt,
     AESEncrypt,
+    AESKeyUnwrap,
+    AESKeyWrap,
     AND,
     addLineNumbers,
     addTextToImage,
@@ -1474,6 +1485,7 @@ const operations = [
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    rabbit,
     railFenceCipherDecode,
     railFenceCipherEncode,
     randomizeColourPalette,
@@ -1612,6 +1624,8 @@ export {
     ADD,
     AESDecrypt,
     AESEncrypt,
+    AESKeyUnwrap,
+    AESKeyWrap,
     AND,
     addLineNumbers,
     addTextToImage,
@@ -1874,6 +1888,7 @@ export {
     RSAEncrypt,
     RSASign,
     RSAVerify,
+    rabbit,
     railFenceCipherDecode,
     railFenceCipherEncode,
     randomizeColourPalette,

package/tests/operations/index.mjs

@@ -128,6 +128,8 @@ import "./tests/NTLM.mjs";
 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";