8.37.0

Added some more metadata to decrypt & verify
Fixes gchq/CyberChef#581

CHANGELOG.md

@@ -2,6 +2,12 @@
 All major and minor version changes will be documented in this file. Details of patch-level version changes can be found in [commit messages](https://github.com/gchq/CyberChef/commits/master).
 
 
+### [8.37.0] - 2019-07-03
+- 'CRC-8 Checksum' operation added [@MShwed] | [#591]
+
+### [8.36.0] - 2019-07-03
+- 'PGP Verify' operation added [@artemisbot] | [#585]
+
 ### [8.35.0] - 2019-07-03
 - 'Sharpen Image', 'Convert Image Format' and 'Add Text To Image' operations added [@j433866] | [#515]
 
@@ -143,6 +149,8 @@ All major and minor version changes will be documented in this file. Details of
 
 
 
+[8.37.0]: https://github.com/gchq/CyberChef/releases/tag/v8.37.0
+[8.36.0]: https://github.com/gchq/CyberChef/releases/tag/v8.36.0
 [8.35.0]: https://github.com/gchq/CyberChef/releases/tag/v8.35.0
 [8.34.0]: https://github.com/gchq/CyberChef/releases/tag/v8.34.0
 [8.33.0]: https://github.com/gchq/CyberChef/releases/tag/v8.33.0
@@ -255,3 +263,5 @@ All major and minor version changes will be documented in this file. Details of
 [#533]: https://github.com/gchq/CyberChef/pull/533
 [#535]: https://github.com/gchq/CyberChef/pull/535
 [#571]: https://github.com/gchq/CyberChef/pull/571
+[#585]: https://github.com/gchq/CyberChef/pull/585
+[#591]: https://github.com/gchq/CyberChef/pull/591

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "cyberchef",
-  "version": "8.35.0",
+  "version": "8.37.0",
   "lockfileVersion": 1,
   "requires": true,
   "dependencies": {

package.json

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

src/core/config/Categories.json

@@ -316,6 +316,7 @@
             "Fletcher-32 Checksum",
             "Fletcher-64 Checksum",
             "Adler-32 Checksum",
+            "CRC-8 Checksum",
             "CRC-16 Checksum",
             "CRC-32 Checksum",
             "TCP/IP Checksum"

src/core/operations/CRC8Checksum.mjs

@@ -0,0 +1,157 @@
+/**
+ * @author mshwed [m@ttshwed.com]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+
+import { toHexFast } from "../lib/Hex";
+
+/**
+ * CRC-8 Checksum operation
+ */
+class CRC8Checksum extends Operation {
+
+    /**
+     * CRC8Checksum constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "CRC-8 Checksum";
+        this.module = "Crypto";
+        this.description = "A cyclic redundancy check (CRC) is an error-detecting code commonly used in digital networks and storage devices to detect accidental changes to raw data.<br><br>The CRC was invented by W. Wesley Peterson in 1961.";
+        this.infoURL = "https://wikipedia.org/wiki/Cyclic_redundancy_check";
+        this.inputType = "ArrayBuffer";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Algorithm",
+                "type": "option",
+                "value": [
+                    "CRC-8",
+                    "CRC-8/CDMA2000",
+                    "CRC-8/DARC",
+                    "CRC-8/DVB-S2",
+                    "CRC-8/EBU",
+                    "CRC-8/I-CODE",
+                    "CRC-8/ITU",
+                    "CRC-8/MAXIM",
+                    "CRC-8/ROHC",
+                    "CRC-8/WCDMA"
+                ]
+            }
+        ];
+    }
+
+    /**
+     * Generates the pre-computed lookup table for byte division
+     *
+     * @param polynomial
+     */
+    calculateCRC8LookupTable(polynomial) {
+        const crc8Table = new Uint8Array(256);
+
+        let currentByte;
+        for (let i = 0; i < 256; i++) {
+            currentByte = i;
+            for (let bit = 0; bit < 8; bit++) {
+                if ((currentByte & 0x80) !== 0) {
+                    currentByte <<= 1;
+                    currentByte ^= polynomial;
+                } else {
+                    currentByte <<= 1;
+                }
+            }
+
+            crc8Table[i] = currentByte;
+        }
+
+        return crc8Table;
+    }
+
+    /**
+     * Calculates the CRC-8 Checksum from an input
+     *
+     * @param {ArrayBuffer} input
+     * @param {number} polynomial
+     * @param {number} initializationValue
+     * @param {boolean} inputReflection
+     * @param {boolean} outputReflection
+     * @param {number} xorOut
+     */
+    calculateCRC8(input, polynomial, initializationValue, inputReflection, outputReflection, xorOut) {
+        const crcSize = 8;
+        const crcTable = this.calculateCRC8LookupTable(polynomial);
+
+        let crc = initializationValue !== 0 ? initializationValue : 0;
+        let currentByte, position;
+
+        input = new Uint8Array(input);
+        for (const inputByte of input) {
+            currentByte = inputReflection ? this.reverseBits(inputByte, crcSize) : inputByte;
+
+            position = (currentByte ^ crc) & 255;
+            crc = crcTable[position];
+        }
+
+        crc = outputReflection ? this.reverseBits(crc, crcSize) : crc;
+
+        if (xorOut !== 0) crc = crc ^ xorOut;
+
+        return toHexFast(new Uint8Array([crc]));
+    }
+
+    /**
+     * Reverse the bits for a given input byte.
+     *
+     * @param {number} input
+     */
+    reverseBits(input, hashSize) {
+        let reversedByte = 0;
+        for (let i = hashSize - 1; i >= 0; i--) {
+            reversedByte |= ((input & 1) << i);
+            input >>= 1;
+        }
+
+        return reversedByte;
+    }
+
+    /**
+     * @param {ArrayBuffer} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    run(input, args) {
+        const algorithm = args[0];
+
+        switch (algorithm) {
+            case "CRC-8":
+                return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x0);
+            case "CRC-8/CDMA2000":
+                return this.calculateCRC8(input, 0x9B, 0xFF, false, false, 0x0);
+            case "CRC-8/DARC":
+                return this.calculateCRC8(input, 0x39, 0x0, true, true, 0x0);
+            case "CRC-8/DVB-S2":
+                return this.calculateCRC8(input, 0xD5, 0x0, false, false, 0x0);
+            case "CRC-8/EBU":
+                return this.calculateCRC8(input, 0x1D, 0xFF, true, true, 0x0);
+            case "CRC-8/I-CODE":
+                return this.calculateCRC8(input, 0x1D, 0xFD, false, false, 0x0);
+            case "CRC-8/ITU":
+                return this.calculateCRC8(input, 0x7, 0x0, false, false, 0x55);
+            case "CRC-8/MAXIM":
+                return this.calculateCRC8(input, 0x31, 0x0, true, true, 0x0);
+            case "CRC-8/ROHC":
+                return this.calculateCRC8(input, 0x7, 0xFF, true, true, 0x0);
+            case "CRC-8/WCDMA":
+                return this.calculateCRC8(input, 0x9B, 0x0, true, true, 0x0);
+            default:
+                throw new OperationError("Unknown checksum algorithm");
+        }
+    }
+}
+
+export default CRC8Checksum;

src/core/operations/GenerateAllHashes.mjs

@@ -26,6 +26,7 @@ import Fletcher16Checksum from "./Fletcher16Checksum";
 import Fletcher32Checksum from "./Fletcher32Checksum";
 import Fletcher64Checksum from "./Fletcher64Checksum";
 import Adler32Checksum from "./Adler32Checksum";
+import CRC8Checksum from "./CRC8Checksum";
 import CRC16Checksum from "./CRC16Checksum";
 import CRC32Checksum from "./CRC32Checksum";
 import BLAKE2b from "./BLAKE2b";
@@ -104,8 +105,9 @@ class GenerateAllHashes extends Operation {
                 "\nFletcher-32: " + (new Fletcher32Checksum).run(byteArray, []) +
                 "\nFletcher-64: " + (new Fletcher64Checksum).run(byteArray, []) +
                 "\nAdler-32:    " + (new Adler32Checksum).run(byteArray, []) +
-                "\nCRC-16:      " + (new CRC16Checksum).run(str, []) +
-                "\nCRC-32:      " + (new CRC32Checksum).run(str, []);
+                "\nCRC-8:       " + (new CRC8Checksum).run(arrayBuffer, ["CRC-8"]) +
+                "\nCRC-16:      " + (new CRC16Checksum).run(arrayBuffer, []) +
+                "\nCRC-32:      " + (new CRC32Checksum).run(arrayBuffer, []);
 
         return output;
     }

src/core/operations/PGPDecryptAndVerify.mjs

@@ -93,7 +93,7 @@ class PGPDecryptAndVerify extends Operation {
                             text += `${signer.username} `;
                         }
                         if (signer.comment) {
-                            text += `${signer.comment} `;
+                            text += `(${signer.comment}) `;
                         }
                         if (signer.email) {
                             text += `<${signer.email}>`;
@@ -101,8 +101,9 @@ class PGPDecryptAndVerify extends Operation {
                         text += "\n";
                     }
                     text += [
+                        `PGP key ID: ${km.get_pgp_short_key_id()}`,
                         `PGP fingerprint: ${km.get_pgp_fingerprint().toString("hex")}`,
-                        `Signed on ${new Date(ds.sig.hashed_subpackets[0].time * 1000).toUTCString()}`,
+                        `Signed on ${new Date(ds.sig.when_generated() * 1000).toUTCString()}`,
                         "----------------------------------\n"
                     ].join("\n");
                     text += unboxedLiterals.toString();

src/core/operations/PGPVerify.mjs

@@ -0,0 +1,111 @@
+/**
+ * @author Matt C [me@mitt.dev]
+ * @copyright Crown Copyright 2019
+ * @license Apache-2.0
+ */
+
+import Operation from "../Operation";
+import OperationError from "../errors/OperationError";
+
+import kbpgp from "kbpgp";
+import { ASP, importPublicKey } from "../lib/PGP";
+import * as es6promisify from "es6-promisify";
+const promisify = es6promisify.default ? es6promisify.default.promisify : es6promisify.promisify;
+
+/**
+ * PGP Verify operation
+ */
+class PGPVerify extends Operation {
+
+    /**
+     * PGPVerify constructor
+     */
+    constructor() {
+        super();
+
+        this.name = "PGP Verify";
+        this.module = "PGP";
+        this.description = [
+            "Input: the ASCII-armoured encrypted PGP message you want to verify.",
+            "<br><br>",
+            "Argument: the ASCII-armoured PGP public key of the signer",
+            "<br><br>",
+            "This operation uses PGP to decrypt a clearsigned message.",
+            "<br><br>",
+            "Pretty Good Privacy is an encryption standard (OpenPGP) used for encrypting, decrypting, and signing messages.",
+            "<br><br>",
+            "This function uses the Keybase implementation of PGP.",
+        ].join("\n");
+        this.infoURL = "https://wikipedia.org/wiki/Pretty_Good_Privacy";
+        this.inputType = "string";
+        this.outputType = "string";
+        this.args = [
+            {
+                "name": "Public key of signer",
+                "type": "text",
+                "value": ""
+            }
+        ];
+    }
+
+    /**
+     * @param {string} input
+     * @param {Object[]} args
+     * @returns {string}
+     */
+    async run(input, args) {
+        const signedMessage = input,
+            [publicKey] = args,
+            keyring = new kbpgp.keyring.KeyRing();
+        let unboxedLiterals;
+
+        if (!publicKey) throw new OperationError("Enter the public key of the signer.");
+        const pubKey = await importPublicKey(publicKey);
+        keyring.add_key_manager(pubKey);
+
+        try {
+            unboxedLiterals = await promisify(kbpgp.unbox)({
+                armored: signedMessage,
+                keyfetch: keyring,
+                asp: ASP
+            });
+            const ds = unboxedLiterals[0].get_data_signer();
+            if (ds) {
+                const km = ds.get_key_manager();
+                if (km) {
+                    const signer = km.get_userids_mark_primary()[0].components;
+                    let text = "Signed by ";
+                    if (signer.email || signer.username || signer.comment) {
+                        if (signer.username) {
+                            text += `${signer.username} `;
+                        }
+                        if (signer.comment) {
+                            text += `(${signer.comment}) `;
+                        }
+                        if (signer.email) {
+                            text += `<${signer.email}>`;
+                        }
+                        text += "\n";
+                    }
+                    text += [
+                        `PGP key ID: ${km.get_pgp_short_key_id()}`,
+                        `PGP fingerprint: ${km.get_pgp_fingerprint().toString("hex")}`,
+                        `Signed on ${new Date(ds.sig.when_generated() * 1000).toUTCString()}`,
+                        "----------------------------------\n"
+                    ].join("\n");
+                    text += unboxedLiterals.toString();
+                    return text.trim();
+                } else {
+                    throw new OperationError("Could not identify a key manager.");
+                }
+            } else {
+                throw new OperationError("The data does not appear to be signed.");
+            }
+        } catch (err) {
+            throw new OperationError(`Couldn't verify message: ${err}`);
+        }
+    }
+
+}
+
+export default PGPVerify;

tests/operations/tests/Checksum.mjs

@@ -29,6 +29,127 @@ const ALL_BYTES = [
 ].join("");
 
 TestRegister.addTests([
+    {
+        name: "CRC-8: nothing",
+        input: "",
+        expectedOutput: "00",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: default check",
+        input: "123456789",
+        expectedOutput: "f4",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: CDMA2000",
+        input: "123456789",
+        expectedOutput: "da",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/CDMA2000"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: DARC",
+        input: "123456789",
+        expectedOutput: "15",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/DARC"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: DVB-S2",
+        input: "123456789",
+        expectedOutput: "bc",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/DVB-S2"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: EBU",
+        input: "123456789",
+        expectedOutput: "97",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/EBU"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: I-CODE",
+        input: "123456789",
+        expectedOutput: "7e",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/I-CODE"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: ITU",
+        input: "123456789",
+        expectedOutput: "a1",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/ITU"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: MAXIM",
+        input: "123456789",
+        expectedOutput: "a1",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/MAXIM"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: ROHC",
+        input: "123456789",
+        expectedOutput: "d0",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/ROHC"]
+            }
+        ]
+    },
+    {
+        name: "CRC-8: WCDMA",
+        input: "123456789",
+        expectedOutput: "25",
+        recipeConfig: [
+            {
+                "op": "CRC-8 Checksum",
+                "args": ["CRC-8/WCDMA"]
+            }
+        ]
+    },
     {
         name: "CRC-16: nothing",
         input: "",
@@ -116,5 +237,5 @@ TestRegister.addTests([
                 "args": []
             }
         ]
-    },
+    }
 ]);

tests/operations/tests/PGP.mjs

@@ -248,7 +248,8 @@ IOE1W/Zqmqzq+4frwnzWwYv9/U1RwIs/qlFVnzliREOzW+om8EncSSd7fQ==
 =fEAT
 -----END PGP MESSAGE-----
 `,
-        expectedOutput: `Signed by PGP fingerprint: e94e06dd0b3744a0e970de9d84246548df98e485
+        expectedOutput: `Signed by PGP key ID: DF98E485
+PGP fingerprint: e94e06dd0b3744a0e970de9d84246548df98e485
 Signed on Tue, 29 May 2018 15:44:52 GMT
 ----------------------------------
 ${UTF8_TEXT}`,
@@ -282,4 +283,30 @@ H2qMY1O7hezH3fp+EZzCAccJMtK7VPk13WAgMRH22HirG4aK1i75IVOtjBgObzDh
             }
         ]
     },
+    {
+        name: "PGP Verify: ASCII, Alice",
+        input: `-----BEGIN PGP SIGNED MESSAGE-----
+Hash: SHA256
+
+A common mistake that people make when trying to design something completely foolproof is to underestimate the ingenuity of complete fools.
+-----BEGIN PGP SIGNATURE-----
+
+iLMEAQEIAB0WIQRLbJy6MLpYOr9qojE+2VNAUiMLOgUCXRTsvwAKCRA+2VNAUiML
+OuaHBADMMNtsuN92Fb+UrDimsv6TDQpbJhDkwp9kZdKYP5HAmSYAhXBG7N+YCMw+
+v2FSpUu9jJiPBm1K1SEwLufQVexoRv6RsBNolRFB07sArau0s0DnIXUchCZWvyTP
+1KsjBnDr84U2b11H58g4DlTT4gQrz30rFuHz9AGmPAtDHbSXIA==
+=vnk/
+-----END PGP SIGNATURE-----`,
+        expectedOutput: `Signed by PGP key ID: DF98E485
+PGP fingerprint: e94e06dd0b3744a0e970de9d84246548df98e485
+Signed on Thu, 27 Jun 2019 16:20:15 GMT
+----------------------------------
+A common mistake that people make when trying to design something completely foolproof is to underestimate the ingenuity of complete fools.`,
+        recipeConfig: [
+            {
+                "op": "PGP Verify",
+                "args": [ALICE_PUBLIC]
+            }
+        ]
+    }
 ]);