cyberchef 11.2.0 → 11.3.0

package/tests/operations/tests/Twofish.mjs

@@ -0,0 +1,486 @@
+/**
+ * Twofish cipher tests.
+ *
+ * Test vectors from the official Twofish paper:
+ * https://www.schneier.com/academic/twofish/
+ *
+ * Note: PKCS5 padding adds an extra block when input is exactly block-aligned.
+ * Round-trip tests verify correct encryption/decryption behavior.
+ *
+ * @author Medjedtxm
+ * @copyright Crown Copyright 2026
+ * @license Apache-2.0
+ */
+
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    // ============================================================
+    // OFFICIAL TEST VECTORS from Bruce Schneier's Twofish paper:
+    // https://www.schneier.com/academic/twofish/
+    // https://www.schneier.com/wp-content/uploads/2015/12/ecb_ival.txt
+    // ============================================================
+    {
+        name: "Twofish Official Vector: 128-bit zero key, zero plaintext",
+        input: "00000000000000000000000000000000",
+        expectedOutput: "9f589f5cf6122c32b6bfec2f2ae8c35a",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00000000000000000000000000000000", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Hex", "NO"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Official Vector: 192-bit zero key, zero plaintext",
+        input: "00000000000000000000000000000000",
+        expectedOutput: "efa71f788965bd4453f860178fc19101",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "000000000000000000000000000000000000000000000000", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Hex", "NO"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Official Vector: 256-bit zero key, zero plaintext",
+        input: "00000000000000000000000000000000",
+        expectedOutput: "57ff739d4dc92c1bd7fc01700cc8216f",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "0000000000000000000000000000000000000000000000000000000000000000", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Hex", "NO"
+                ]
+            }
+        ]
+    },
+    // Decrypt verification of official vectors
+    {
+        name: "Twofish Official Vector Decrypt: 128-bit zero key",
+        input: "9f589f5cf6122c32b6bfec2f2ae8c35a",
+        expectedOutput: "00000000000000000000000000000000",
+        recipeConfig: [
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00000000000000000000000000000000", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Hex", "NO"
+                ]
+            }
+        ]
+    },
+    // ============================================================
+    // Round-trip tests for ECB mode with various key sizes
+    // ============================================================
+    {
+        name: "Twofish Round-trip: ECB 128-bit key",
+        input: "Hello, World!!!",
+        expectedOutput: "Hello, World!!!",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: ECB 192-bit key",
+        input: "Testing Twofish with 192-bit key",
+        expectedOutput: "Testing Twofish with 192-bit key",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f1011121314151617", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f1011121314151617", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: ECB 256-bit key",
+        input: "Testing Twofish with 256-bit key encryption",
+        expectedOutput: "Testing Twofish with 256-bit key encryption",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Round-trip tests for CBC mode
+    {
+        name: "Twofish Round-trip: CBC 128-bit key",
+        input: "The quick brown fox jumps over the lazy dog",
+        expectedOutput: "The quick brown fox jumps over the lazy dog",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: CBC 192-bit key",
+        input: "Testing Twofish with 192-bit key in CBC mode",
+        expectedOutput: "Testing Twofish with 192-bit key in CBC mode",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f1011121314151617", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f1011121314151617", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: CBC 256-bit key",
+        input: "Testing Twofish with 256-bit key in CBC mode",
+        expectedOutput: "Testing Twofish with 256-bit key in CBC mode",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "CBC", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Round-trip tests for CFB mode
+    {
+        name: "Twofish Round-trip: CFB 128-bit key",
+        input: "Testing Twofish CFB mode encryption",
+        expectedOutput: "Testing Twofish CFB mode encryption",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "deadbeefcafebabe0123456789abcdef", option: "Hex" },
+                    { string: "0102030405060708090a0b0c0d0e0f10", option: "Hex" },
+                    "CFB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "deadbeefcafebabe0123456789abcdef", option: "Hex" },
+                    { string: "0102030405060708090a0b0c0d0e0f10", option: "Hex" },
+                    "CFB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Round-trip tests for OFB mode
+    {
+        name: "Twofish Round-trip: OFB 128-bit key",
+        input: "Testing Twofish OFB mode encryption",
+        expectedOutput: "Testing Twofish OFB mode encryption",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "OFB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    "OFB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Round-trip tests for CTR mode
+    {
+        name: "Twofish Round-trip: CTR 128-bit key",
+        input: "Testing Twofish CTR mode encryption",
+        expectedOutput: "Testing Twofish CTR mode encryption",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "00000000000000000000000000000001", option: "Hex" },
+                    "CTR", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "00000000000000000000000000000001", option: "Hex" },
+                    "CTR", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // UTF8 key tests
+    {
+        name: "Twofish Round-trip: UTF8 key (16 bytes)",
+        input: "Secret message!",
+        expectedOutput: "Secret message!",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "MySecretPassword", option: "UTF8" },
+                    { string: "InitVectorHere!!", option: "UTF8" },
+                    "CBC", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "MySecretPassword", option: "UTF8" },
+                    { string: "InitVectorHere!!", option: "UTF8" },
+                    "CBC", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Various input length tests
+    {
+        name: "Twofish Round-trip: 1 byte input",
+        input: "A",
+        expectedOutput: "A",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: 15 byte input",
+        input: "123456789012345",
+        expectedOutput: "123456789012345",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: 16 byte input (exact block)",
+        input: "1234567890123456",
+        expectedOutput: "1234567890123456",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: 17 byte input",
+        input: "12345678901234567",
+        expectedOutput: "12345678901234567",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+    {
+        name: "Twofish Round-trip: 32 byte input (two blocks)",
+        input: "12345678901234567890123456789012",
+        expectedOutput: "12345678901234567890123456789012",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Binary data test
+    {
+        name: "Twofish Round-trip: Binary data",
+        input: "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+        expectedOutput: "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    "CBC", "Raw", "Hex", "PKCS5"
+                ]
+            },
+            {
+                op: "Twofish Decrypt",
+                args: [
+                    { string: "ffeeddccbbaa99887766554433221100", option: "Hex" },
+                    { string: "00112233445566778899aabbccddeeff", option: "Hex" },
+                    "CBC", "Hex", "Raw", "PKCS5"
+                ]
+            }
+        ]
+    },
+
+    // Consistency test - same input should always produce same output
+    {
+        name: "Twofish Encrypt: 128-bit key consistency test",
+        input: "TestData12345678",
+        expectedOutput: "8aed2d3a85dc3e0b663ba1fe1fdaf056771d591428af301d69fa1e227d083527",
+        recipeConfig: [
+            {
+                op: "Twofish Encrypt",
+                args: [
+                    { string: "00000000000000000000000000000000", option: "Hex" },
+                    { string: "", option: "Hex" },
+                    "ECB", "Raw", "Hex", "PKCS5"
+                ]
+            }
+        ]
+    }
+]);

package/tests/operations/tests/URLEncodeDecode.mjs

@@ -89,4 +89,30 @@ TestRegister.addTests([
             },
         ],
     },
+    {
+        name: "URLEncode: encodes UTF-8 text as UTF-8 bytes",
+        input: "你好",
+        expectedOutput: "%E4%BD%A0%E5%A5%BD",
+        recipeConfig: [
+            {
+                op: "URL Encode",
+                args: [false],
+            },
+        ],
+    },
+    {
+        name: "URLEncode: preserves raw bytes from From Hex",
+        input: "6c6567697466696c6580000000000000000000000000000000000000000000000000000000000000000000000000000000000000000090746869737761737375706f736564746f6265616e6578706c6f6974",
+        expectedOutput: "legitfile%80%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%00%90thiswassuposedtobeanexploit",
+        recipeConfig: [
+            {
+                op: "From Hex",
+                args: ["None"],
+            },
+            {
+                op: "URL Encode",
+                args: [false],
+            },
+        ],
+    },
 ]);

package/tests/operations/tests/UnescapeUnicodeCharacters.mjs

@@ -0,0 +1,88 @@
+/**
+ * Unescape Unicode Characters operation tests.
+ *
+ * @author williballenthin
+ * @copyright Crown Copyright 2024
+ * @license Apache-2.0
+ */
+import TestRegister from "../../lib/TestRegister.mjs";
+
+TestRegister.addTests([
+    {
+        name: "Unescape Unicode Characters: \\u 4-digit BMP",
+        input: "\\u03c3\\u03bf\\u03c5",
+        expectedOutput: "σου",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["\\u"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: %u 4-digit BMP",
+        input: "%u03c3%u03bf%u03c5",
+        expectedOutput: "σου",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["%u"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: U+ 4-digit BMP",
+        input: "U+0041",
+        expectedOutput: "A",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["U+"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: U+ 5-digit astral plane emoji",
+        input: "U+1F600",
+        expectedOutput: "\u{1F600}",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["U+"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: U+ 6-digit zero-padded",
+        input: "U+000041",
+        expectedOutput: "A",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["U+"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: U+ mixed lengths",
+        input: "U+0041 U+1F600 U+000042",
+        expectedOutput: "A \u{1F600} B",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["U+"],
+            },
+        ],
+    },
+    {
+        name: "Unescape Unicode Characters: passthrough with no matches",
+        input: "hello world",
+        expectedOutput: "hello world",
+        recipeConfig: [
+            {
+                op: "Unescape Unicode Characters",
+                args: ["\\u"],
+            },
+        ],
+    },
+]);

package/tests/operations/tests/Wrap.mjs

@@ -40,5 +40,49 @@ TestRegister.addTests([
                 "args": [10]
             },
         ],
+    },
+    {
+        name: "Wrap rejects zero line width",
+        input: "hello",
+        expectedOutput: "Line Width must be greater than or equal to 1.",
+        recipeConfig: [
+            {
+                "op": "Wrap",
+                "args": [0]
+            },
+        ],
+    },
+    {
+        name: "Wrap rejects negative line width",
+        input: "hello",
+        expectedOutput: "Line Width must be greater than or equal to 1.",
+        recipeConfig: [
+            {
+                "op": "Wrap",
+                "args": [-1]
+            },
+        ],
+    },
+    {
+        name: "Wrap rejects non-integer line width",
+        input: "hello",
+        expectedOutput: "Line Width must be an integer.",
+        recipeConfig: [
+            {
+                "op": "Wrap",
+                "args": [1.1]
+            },
+        ],
+    },
+    {
+        name: "Wrap rejects excessive line width",
+        input: "hello",
+        expectedOutput: "Line Width must be less than or equal to 65536.",
+        recipeConfig: [
+            {
+                "op": "Wrap",
+                "args": [65537]
+            },
+        ],
     }
 ]);

package/webpack.config.js

@@ -88,8 +88,8 @@ module.exports = {
                     from: "tesseract/**/*",
                     to: "assets/"
                 }, {
-                    context: "node_modules/tesseract.js/",
-                    from: "dist/worker.min.js",
+                    context: "node_modules/tesseract.js/dist",
+                    from: "worker.min.js",
                     to: "assets/tesseract"
                 }, {
                     context: "node_modules/tesseract.js-core/",
@@ -221,7 +221,7 @@ module.exports = {
             },
             { // Third party images are inlined
                 test: /\.(png|jpg|gif)$/,
-                exclude: /web\/static/,
+                include: /node_modules/,
                 type: "asset/inline",
             },
         ]