Merge branch 'esmconversion' of https://github.com/artemisbot/CyberChef into esm

src/core/operations/legacy/Extract.js

@@ -1,333 +0,0 @@
-import XRegExp from "xregexp";
-
-
-/**
- * Identifier extraction operations.
- *
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2016
- * @license Apache-2.0
- *
- * @namespace
- */
-const Extract = {
-
-    /**
-     * Runs search operations across the input data using regular expressions.
-     *
-     * @private
-     * @param {string} input
-     * @param {RegExp} searchRegex
-     * @param {RegExp} removeRegex - A regular expression defining results to remove from the
-     *      final list
-     * @param {boolean} includeTotal - Whether or not to include the total number of results
-     * @returns {string}
-     */
-    _search: function(input, searchRegex, removeRegex, includeTotal) {
-        let output = "",
-            total = 0,
-            match;
-
-        while ((match = searchRegex.exec(input))) {
-            // Moves pointer when an empty string is matched (prevents infinite loop)
-            if (match.index === searchRegex.lastIndex) {
-                searchRegex.lastIndex++;
-            }
-
-            if (removeRegex && removeRegex.test(match[0]))
-                continue;
-            total++;
-            output += match[0] + "\n";
-        }
-
-        if (includeTotal)
-            output = "Total found: " + total + "\n\n" + output;
-
-        return output;
-    },
-
-
-    /**
-     * @constant
-     * @default
-     */
-    MIN_STRING_LEN: 4,
-    /**
-     * @constant
-     * @default
-     */
-    STRING_MATCH_TYPE: [
-        "[ASCII]", "Alphanumeric + punctuation (A)", "All printable chars (A)", "Null-terminated strings (A)",
-        "[Unicode]", "Alphanumeric + punctuation (U)", "All printable chars (U)", "Null-terminated strings (U)"
-    ],
-    /**
-     * @constant
-     * @default
-     */
-    ENCODING_LIST: ["Single byte", "16-bit littleendian", "16-bit bigendian", "All"],
-    /**
-     * @constant
-     * @default
-     */
-    DISPLAY_TOTAL: false,
-
-    /**
-     * Strings operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runStrings: function(input, args) {
-        const encoding = args[0],
-            minLen = args[1],
-            matchType = args[2],
-            displayTotal = args[3],
-            alphanumeric = "A-Z\\d",
-            punctuation = "/\\-:.,_$%'\"()<>= !\\[\\]{}@",
-            printable = "\x20-\x7e",
-            uniAlphanumeric = "\\pL\\pN",
-            uniPunctuation = "\\pP\\pZ",
-            uniPrintable = "\\pL\\pM\\pZ\\pS\\pN\\pP";
-
-        let strings = "";
-
-        switch (matchType) {
-            case "Alphanumeric + punctuation (A)":
-                strings = `[${alphanumeric + punctuation}]`;
-                break;
-            case "All printable chars (A)":
-            case "Null-terminated strings (A)":
-                strings = `[${printable}]`;
-                break;
-            case "Alphanumeric + punctuation (U)":
-                strings = `[${uniAlphanumeric + uniPunctuation}]`;
-                break;
-            case "All printable chars (U)":
-            case "Null-terminated strings (U)":
-                strings = `[${uniPrintable}]`;
-                break;
-        }
-
-        // UTF-16 support is hacked in by allowing null bytes on either side of the matched chars
-        switch (encoding) {
-            case "All":
-                strings = `(\x00?${strings}\x00?)`;
-                break;
-            case "16-bit littleendian":
-                strings = `(${strings}\x00)`;
-                break;
-            case "16-bit bigendian":
-                strings = `(\x00${strings})`;
-                break;
-            case "Single byte":
-            default:
-                break;
-        }
-
-        strings = `${strings}{${minLen},}`;
-
-        if (matchType.includes("Null-terminated")) {
-            strings += "\x00";
-        }
-
-        const regex = new XRegExp(strings, "ig");
-
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-
-    /**
-     * @constant
-     * @default
-     */
-    INCLUDE_IPV4: true,
-    /**
-     * @constant
-     * @default
-     */
-    INCLUDE_IPV6: false,
-    /**
-     * @constant
-     * @default
-     */
-    REMOVE_LOCAL: false,
-
-    /**
-     * Extract IP addresses operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runIp: function(input, args) {
-        let includeIpv4  = args[0],
-            includeIpv6  = args[1],
-            removeLocal  = args[2],
-            displayTotal = args[3],
-            ipv4 = "(?:(?:\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d|\\d)(?:\\/\\d{1,2})?",
-            ipv6 = "((?=.*::)(?!.*::.+::)(::)?([\\dA-F]{1,4}:(:|\\b)|){5}|([\\dA-F]{1,4}:){6})((([\\dA-F]{1,4}((?!\\3)::|:\\b|(?![\\dA-F])))|(?!\\2\\3)){2}|(((2[0-4]|1\\d|[1-9])?\\d|25[0-5])\\.?\\b){4})",
-            ips  = "";
-
-        if (includeIpv4 && includeIpv6) {
-            ips = ipv4 + "|" + ipv6;
-        } else if (includeIpv4) {
-            ips = ipv4;
-        } else if (includeIpv6) {
-            ips = ipv6;
-        }
-
-        if (ips) {
-            const regex = new RegExp(ips, "ig");
-
-            if (removeLocal) {
-                let ten = "10\\..+",
-                    oneninetwo = "192\\.168\\..+",
-                    oneseventwo = "172\\.(?:1[6-9]|2\\d|3[01])\\..+",
-                    onetwoseven = "127\\..+",
-                    removeRegex = new RegExp("^(?:" + ten + "|" + oneninetwo +
-                        "|" + oneseventwo + "|" + onetwoseven + ")");
-
-                return Extract._search(input, regex, removeRegex, displayTotal);
-            } else {
-                return Extract._search(input, regex, null, displayTotal);
-            }
-        } else {
-            return "";
-        }
-    },
-
-
-    /**
-     * Extract email addresses operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runEmail: function(input, args) {
-        let displayTotal = args[0],
-            regex = /\b\w[-.\w]*@[-\w]+(?:\.[-\w]+)*\.[A-Z]{2,4}\b/ig;
-
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-
-    /**
-     * Extract MAC addresses operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runMac: function(input, args) {
-        let displayTotal = args[0],
-            regex = /[A-F\d]{2}(?:[:-][A-F\d]{2}){5}/ig;
-
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-
-    /**
-     * Extract URLs operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runUrls: function(input, args) {
-        let displayTotal = args[0],
-            protocol = "[A-Z]+://",
-            hostname = "[-\\w]+(?:\\.\\w[-\\w]*)+",
-            port = ":\\d+",
-            path = "/[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]*";
-
-        path += "(?:[.!,?]+[^.!,?\"<>\\[\\]{}\\s\\x7F-\\xFF]+)*";
-        const regex = new RegExp(protocol + hostname + "(?:" + port +
-            ")?(?:" + path + ")?", "ig");
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-
-    /**
-     * Extract domains operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runDomains: function(input, args) {
-        const displayTotal = args[0],
-            regex = /\b((?=[a-z0-9-]{1,63}\.)(xn--)?[a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,63}\b/ig;
-
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-
-    /**
-     * @constant
-     * @default
-     */
-    INCLUDE_WIN_PATH: true,
-    /**
-     * @constant
-     * @default
-     */
-    INCLUDE_UNIX_PATH: true,
-
-    /**
-     * Extract file paths operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runFilePaths: function(input, args) {
-        let includeWinPath = args[0],
-            includeUnixPath = args[1],
-            displayTotal = args[2],
-            winDrive = "[A-Z]:\\\\",
-            winName = "[A-Z\\d][A-Z\\d\\- '_\\(\\)~]{0,61}",
-            winExt = "[A-Z\\d]{1,6}",
-            winPath = winDrive + "(?:" + winName + "\\\\?)*" + winName +
-                "(?:\\." + winExt + ")?",
-            unixPath = "(?:/[A-Z\\d.][A-Z\\d\\-.]{0,61})+",
-            filePaths = "";
-
-        if (includeWinPath && includeUnixPath) {
-            filePaths = winPath + "|" + unixPath;
-        } else if (includeWinPath) {
-            filePaths = winPath;
-        } else if (includeUnixPath) {
-            filePaths = unixPath;
-        }
-
-        if (filePaths) {
-            const regex = new RegExp(filePaths, "ig");
-            return Extract._search(input, regex, null, displayTotal);
-        } else {
-            return "";
-        }
-    },
-
-
-    /**
-     * Extract dates operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runDates: function(input, args) {
-        let displayTotal = args[0],
-            date1 = "(?:19|20)\\d\\d[- /.](?:0[1-9]|1[012])[- /.](?:0[1-9]|[12][0-9]|3[01])", // yyyy-mm-dd
-            date2 = "(?:0[1-9]|[12][0-9]|3[01])[- /.](?:0[1-9]|1[012])[- /.](?:19|20)\\d\\d", // dd/mm/yyyy
-            date3 = "(?:0[1-9]|1[012])[- /.](?:0[1-9]|[12][0-9]|3[01])[- /.](?:19|20)\\d\\d", // mm/dd/yyyy
-            regex = new RegExp(date1 + "|" + date2 + "|" + date3, "ig");
-
-        return Extract._search(input, regex, null, displayTotal);
-    },
-
-};
-
-export default Extract;

src/core/operations/legacy/PGP.js

@@ -1,364 +0,0 @@
-import * as kbpgp from "kbpgp";
-import {promisify} from "es6-promisify";
-
-
-/**
- * PGP operations.
- *
- * @author tlwr [toby@toby.codes]
- * @author Matt C [matt@artemisbot.uk]
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2017
- * @license Apache-2.0
- *
- * @namespace
- */
-const PGP = {
-
-    /**
-     * @constant
-     * @default
-     */
-    KEY_TYPES: ["RSA-1024", "RSA-2048", "RSA-4096", "ECC-256", "ECC-384"],
-
-
-    /**
-     * Get size of subkey
-     *
-     * @private
-     * @param {number} keySize
-     * @returns {number}
-     */
-    _getSubkeySize(keySize) {
-        return {
-            1024: 1024,
-            2048: 1024,
-            4096: 2048,
-            256:   256,
-            384:   256,
-        }[keySize];
-    },
-
-
-    /**
-     * Progress callback
-     *
-     * @private
-     */
-    _ASP: new kbpgp.ASP({
-        "progress_hook": info => {
-            let msg = "";
-
-            switch (info.what) {
-                case "guess":
-                    msg = "Guessing a prime";
-                    break;
-                case "fermat":
-                    msg = "Factoring prime using Fermat's factorization method";
-                    break;
-                case "mr":
-                    msg = "Performing Miller-Rabin primality test";
-                    break;
-                case "passed_mr":
-                    msg = "Passed Miller-Rabin primality test";
-                    break;
-                case "failed_mr":
-                    msg = "Failed Miller-Rabin primality test";
-                    break;
-                case "found":
-                    msg = "Prime found";
-                    break;
-                default:
-                    msg = `Stage: ${info.what}`;
-            }
-
-            if (ENVIRONMENT_IS_WORKER())
-                self.sendStatusMessage(msg);
-        }
-    }),
-
-
-    /**
-     * Import private key and unlock if necessary
-     *
-     * @private
-     * @param {string} privateKey
-     * @param {string} [passphrase]
-     * @returns {Object}
-     */
-    async _importPrivateKey(privateKey, passphrase) {
-        try {
-            const key = await promisify(kbpgp.KeyManager.import_from_armored_pgp)({
-                armored: privateKey,
-                opts: {
-                    "no_check_keys": true
-                }
-            });
-            if (key.is_pgp_locked()) {
-                if (passphrase) {
-                    await promisify(key.unlock_pgp.bind(key))({
-                        passphrase
-                    });
-                } else {
-                    throw "Did not provide passphrase with locked private key.";
-                }
-            }
-            return key;
-        } catch (err) {
-            throw `Could not import private key: ${err}`;
-        }
-    },
-
-
-    /**
-     * Import public key
-     *
-     * @private
-     * @param {string} publicKey
-     * @returns {Object}
-     */
-    async _importPublicKey (publicKey) {
-        try {
-            const key = await promisify(kbpgp.KeyManager.import_from_armored_pgp)({
-                armored: publicKey,
-                opts: {
-                    "no_check_keys": true
-                }
-            });
-            return key;
-        } catch (err) {
-            throw `Could not import public key: ${err}`;
-        }
-    },
-
-
-    /**
-     * Generate PGP Key Pair operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runGenerateKeyPair(input, args) {
-        let [keyType, keySize] = args[0].split("-"),
-            password = args[1],
-            name = args[2],
-            email = args[3],
-            userIdentifier = "";
-
-        if (name) userIdentifier += name;
-        if (email) userIdentifier += ` <${email}>`;
-
-        let flags = kbpgp.const.openpgp.certify_keys;
-        flags |= kbpgp.const.openpgp.sign_data;
-        flags |= kbpgp.const.openpgp.auth;
-        flags |= kbpgp.const.openpgp.encrypt_comm;
-        flags |= kbpgp.const.openpgp.encrypt_storage;
-
-        let keyGenerationOptions = {
-            userid: userIdentifier,
-            ecc: keyType === "ecc",
-            primary: {
-                "nbits": keySize,
-                "flags": flags,
-                "expire_in": 0
-            },
-            subkeys: [{
-                "nbits": PGP._getSubkeySize(keySize),
-                "flags": kbpgp.const.openpgp.sign_data,
-                "expire_in": 86400 * 365 * 8
-            }, {
-                "nbits": PGP._getSubkeySize(keySize),
-                "flags": kbpgp.const.openpgp.encrypt_comm | kbpgp.const.openpgp.encrypt_storage,
-                "expire_in": 86400 * 365 * 2
-            }],
-            asp: PGP._ASP
-        };
-
-        return new Promise(async (resolve, reject) => {
-            try {
-                const unsignedKey = await promisify(kbpgp.KeyManager.generate)(keyGenerationOptions);
-                await promisify(unsignedKey.sign.bind(unsignedKey))({});
-                let signedKey = unsignedKey;
-                let privateKeyExportOptions = {};
-                if (password) privateKeyExportOptions.passphrase = password;
-                const privateKey = await promisify(signedKey.export_pgp_private.bind(signedKey))(privateKeyExportOptions);
-                const publicKey = await promisify(signedKey.export_pgp_public.bind(signedKey))({});
-                resolve(privateKey + "\n" + publicKey.trim());
-            } catch (err) {
-                reject(`Error whilst generating key pair: ${err}`);
-            }
-        });
-    },
-
-
-    /**
-     * PGP Encrypt operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    async runEncrypt(input, args) {
-        let plaintextMessage = input,
-            plainPubKey = args[0],
-            key,
-            encryptedMessage;
-
-        if (!plainPubKey) return "Enter the public key of the recipient.";
-
-        try {
-            key = await promisify(kbpgp.KeyManager.import_from_armored_pgp)({
-                armored: plainPubKey,
-            });
-        } catch (err) {
-            throw `Could not import public key: ${err}`;
-        }
-
-        try {
-            encryptedMessage = await promisify(kbpgp.box)({
-                "msg": plaintextMessage,
-                "encrypt_for": key,
-                "asp": PGP._ASP
-            });
-        } catch (err) {
-            throw `Couldn't encrypt message with provided public key: ${err}`;
-        }
-
-        return encryptedMessage.toString();
-    },
-
-
-    /**
-     * PGP Decrypt operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    async runDecrypt(input, args) {
-        let encryptedMessage = input,
-            privateKey = args[0],
-            passphrase = args[1],
-            keyring = new kbpgp.keyring.KeyRing(),
-            plaintextMessage;
-
-        if (!privateKey) return "Enter the private key of the recipient.";
-
-        const key = await PGP._importPrivateKey(privateKey, passphrase);
-        keyring.add_key_manager(key);
-
-        try {
-            plaintextMessage = await promisify(kbpgp.unbox)({
-                armored: encryptedMessage,
-                keyfetch: keyring,
-                asp: PGP._ASP
-            });
-        } catch (err) {
-            throw `Couldn't decrypt message with provided private key: ${err}`;
-        }
-
-        return plaintextMessage.toString();
-    },
-
-
-    /**
-     * PGP Sign Message operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    async runSign(input, args) {
-        let message = input,
-            privateKey = args[0],
-            passphrase = args[1],
-            publicKey = args[2],
-            signedMessage;
-
-        if (!privateKey) return "Enter the private key of the signer.";
-        if (!publicKey) return "Enter the public key of the recipient.";
-        const privKey = await PGP._importPrivateKey(privateKey, passphrase);
-        const pubKey = await PGP._importPublicKey(publicKey);
-
-        try {
-            signedMessage = await promisify(kbpgp.box)({
-                "msg": message,
-                "encrypt_for": pubKey,
-                "sign_with": privKey,
-                "asp": PGP._ASP
-            });
-        } catch (err) {
-            throw `Couldn't sign message: ${err}`;
-        }
-
-        return signedMessage;
-    },
-
-
-    /**
-     * PGP Verify Message operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    async runVerify(input, args) {
-        let signedMessage = input,
-            publicKey = args[0],
-            privateKey = args[1],
-            passphrase = args[2],
-            keyring = new kbpgp.keyring.KeyRing(),
-            unboxedLiterals;
-
-        if (!publicKey) return "Enter the public key of the signer.";
-        if (!privateKey) return "Enter the private key of the recipient.";
-        const privKey = await PGP._importPrivateKey(privateKey, passphrase);
-        const pubKey = await PGP._importPublicKey(publicKey);
-        keyring.add_key_manager(privKey);
-        keyring.add_key_manager(pubKey);
-
-        try {
-            unboxedLiterals = await promisify(kbpgp.unbox)({
-                armored: signedMessage,
-                keyfetch: keyring,
-                asp: PGP._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 fingerprint: ${km.get_pgp_fingerprint().toString("hex")}`,
-                        `Signed on ${new Date(ds.sig.hashed_subpackets[0].time * 1000).toUTCString()}`,
-                        "----------------------------------\n"
-                    ].join("\n");
-                    text += unboxedLiterals.toString();
-                    return text.trim();
-                } else {
-                    return "Could not identify a key manager.";
-                }
-            } else {
-                return "The data does not appear to be signed.";
-            }
-        } catch (err) {
-            return `Couldn't verify message: ${err}`;
-        }
-    },
-};
-
-export default PGP;

src/core/operations/legacy/URL.js

@@ -1,118 +0,0 @@
-/* globals unescape */
-import url from "url";
-
-
-/**
- * URL operations.
- * Namespace is appended with an underscore to prevent overwriting the global URL object.
- *
- * @author n1474335 [n1474335@gmail.com]
- * @copyright Crown Copyright 2016
- * @license Apache-2.0
- *
- * @namespace
- */
-const URL_ = {
-
-    /**
-     * @constant
-     * @default
-     */
-    ENCODE_ALL: false,
-
-    /**
-     * URL Encode operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runTo: function(input, args) {
-        const encodeAll = args[0];
-        return encodeAll ? URL_._encodeAllChars(input) : encodeURI(input);
-    },
-
-
-    /**
-     * URL Decode operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runFrom: function(input, args) {
-        const data = input.replace(/\+/g, "%20");
-        try {
-            return decodeURIComponent(data);
-        } catch (err) {
-            return unescape(data);
-        }
-    },
-
-
-    /**
-     * Parse URI operation.
-     *
-     * @param {string} input
-     * @param {Object[]} args
-     * @returns {string}
-     */
-    runParse: function(input, args) {
-        const uri = url.parse(input, true);
-
-        let output = "";
-
-        if (uri.protocol) output += "Protocol:\t" + uri.protocol + "\n";
-        if (uri.auth) output += "Auth:\t\t" + uri.auth + "\n";
-        if (uri.hostname) output += "Hostname:\t" + uri.hostname + "\n";
-        if (uri.port) output += "Port:\t\t" + uri.port + "\n";
-        if (uri.pathname) output += "Path name:\t" + uri.pathname + "\n";
-        if (uri.query) {
-            let keys = Object.keys(uri.query),
-                padding = 0;
-
-            keys.forEach(k => {
-                padding = (k.length > padding) ? k.length : padding;
-            });
-
-            output += "Arguments:\n";
-            for (let key in uri.query) {
-                output += "\t" + key.padEnd(padding, " ");
-                if (uri.query[key].length) {
-                    output += " = " + uri.query[key] + "\n";
-                } else {
-                    output += "\n";
-                }
-            }
-        }
-        if (uri.hash) output += "Hash:\t\t" + uri.hash + "\n";
-
-        return output;
-    },
-
-
-    /**
-     * URL encodes additional special characters beyond the standard set.
-     *
-     * @private
-     * @param {string} str
-     * @returns {string}
-     */
-    _encodeAllChars: function(str) {
-        //TODO Do this programatically
-        return encodeURIComponent(str)
-            .replace(/!/g, "%21")
-            .replace(/#/g, "%23")
-            .replace(/'/g, "%27")
-            .replace(/\(/g, "%28")
-            .replace(/\)/g, "%29")
-            .replace(/\*/g, "%2A")
-            .replace(/-/g, "%2D")
-            .replace(/\./g, "%2E")
-            .replace(/_/g, "%5F")
-            .replace(/~/g, "%7E");
-    },
-
-};
-
-export default URL_;