floCrypto.js

(function (EXPORTS) { //floCrypto v2.3.6b
    /* FLO Crypto Operators */
    'use strict';
    const floCrypto = EXPORTS;

    const p = BigInteger("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", 16);
    const ecparams = EllipticCurve.getSECCurveByName("secp256k1");
    const ascii_alternatives = `‘ '\n’ '\n“ "\n” "\n– --\n— ---\n≥ >=\n≤ <=\n≠ !=\n× *\n÷ /\n← <-\n→ ->\n↔ <->\n⇒ =>\n⇐ <=\n⇔ <=>`;
    const exponent1 = () => p.add(BigInteger.ONE).divide(BigInteger("4"));
    coinjs.compressed = true; //defaulting coinjs compressed to true;

    function calculateY(x) {
        let exp = exponent1();
        // x is x value of public key in BigInteger format without 02 or 03 or 04 prefix
        return x.modPow(BigInteger("3"), p).add(BigInteger("7")).mod(p).modPow(exp, p)
    }

    function getUncompressedPublicKey(compressedPublicKey) {
        // Fetch x from compressedPublicKey
        let pubKeyBytes = Crypto.util.hexToBytes(compressedPublicKey);
        const prefix = pubKeyBytes.shift() // remove prefix
        let prefix_modulus = prefix % 2;
        pubKeyBytes.unshift(0) // add prefix 0
        let x = new BigInteger(pubKeyBytes)
        let xDecimalValue = x.toString()
        // Fetch y
        let y = calculateY(x);
        let yDecimalValue = y.toString();
        // verify y value
        let resultBigInt = y.mod(BigInteger("2"));
        let check = resultBigInt.toString() % 2;
        if (prefix_modulus !== check)
            yDecimalValue = y.negate().mod(p).toString();
        return {
            x: xDecimalValue,
            y: yDecimalValue
        };
    }

    function getSenderPublicKeyString() {
        let privateKey = ellipticCurveEncryption.senderRandom();
        var senderPublicKeyString = ellipticCurveEncryption.senderPublicString(privateKey);
        return {
            privateKey: privateKey,
            senderPublicKeyString: senderPublicKeyString
        }
    }

    function deriveSharedKeySender(receiverPublicKeyHex, senderPrivateKey) {
        let receiverPublicKeyString = getUncompressedPublicKey(receiverPublicKeyHex);
        var senderDerivedKey = ellipticCurveEncryption.senderSharedKeyDerivation(
            receiverPublicKeyString.x, receiverPublicKeyString.y, senderPrivateKey);
        return senderDerivedKey;
    }

    function deriveSharedKeyReceiver(senderPublicKeyString, receiverPrivateKey) {
        return ellipticCurveEncryption.receiverSharedKeyDerivation(
            senderPublicKeyString.XValuePublicString, senderPublicKeyString.YValuePublicString, receiverPrivateKey);
    }

    function getReceiverPublicKeyString(privateKey) {
        return ellipticCurveEncryption.receiverPublicString(privateKey);
    }

    function wifToDecimal(pk_wif, isPubKeyCompressed = false) {
        let pk = Bitcoin.Base58.decode(pk_wif)
        pk.shift()
        pk.splice(-4, 4)
        //If the private key corresponded to a compressed public key, also drop the last byte (it should be 0x01).
        if (isPubKeyCompressed == true) pk.pop()
        pk.unshift(0)
        let privateKeyDecimal = BigInteger(pk).toString()
        let privateKeyHex = Crypto.util.bytesToHex(pk)
        return {
            privateKeyDecimal: privateKeyDecimal,
            privateKeyHex: privateKeyHex
        }
    }

    //generate a random Interger within range
    floCrypto.randInt = function (min, max) {
        min = Math.ceil(min);
        max = Math.floor(max);
        return Math.floor(securedMathRandom() * (max - min + 1)) + min;
    }

    //generate a random String within length (options : alphaNumeric chars only)
    floCrypto.randString = function (length, alphaNumeric = true) {
        var result = '';
        var characters = alphaNumeric ? 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' :
            'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_+-./*?@#&$<>=[]{}():';
        for (var i = 0; i < length; i++)
            result += characters.charAt(Math.floor(securedMathRandom() * characters.length));
        return result;
    }

    //Encrypt Data using public-key
    floCrypto.encryptData = function (data, receiverPublicKeyHex) {
        var senderECKeyData = getSenderPublicKeyString();
        var senderDerivedKey = deriveSharedKeySender(receiverPublicKeyHex, senderECKeyData.privateKey);
        let senderKey = senderDerivedKey.XValue + senderDerivedKey.YValue;
        let secret = Crypto.AES.encrypt(data, senderKey);
        return {
            secret: secret,
            senderPublicKeyString: senderECKeyData.senderPublicKeyString
        };
    }

    //Decrypt Data using private-key
    floCrypto.decryptData = function (data, privateKeyHex) {
        var receiverECKeyData = {};
        if (typeof privateKeyHex !== "string") throw new Error("No private key found.");
        let privateKey = wifToDecimal(privateKeyHex, true);
        if (typeof privateKey.privateKeyDecimal !== "string") throw new Error("Failed to detremine your private key.");
        receiverECKeyData.privateKey = privateKey.privateKeyDecimal;
        var receiverDerivedKey = deriveSharedKeyReceiver(data.senderPublicKeyString, receiverECKeyData.privateKey);
        let receiverKey = receiverDerivedKey.XValue + receiverDerivedKey.YValue;
        let decryptMsg = Crypto.AES.decrypt(data.secret, receiverKey);
        return decryptMsg;
    }

    //Sign data using private-key
    floCrypto.signData = function (data, privateKeyHex) {
        if (typeof privateKeyHex !== "string") throw new Error("No private key found.");
        var key = new Bitcoin.ECKey(privateKeyHex);
        var messageHash = Crypto.SHA256(data);
        var messageSign = Bitcoin.ECDSA.sign(messageHash, key.priv);
        var sighex = Crypto.util.bytesToHex(messageSign);
        return sighex;
    }

    //Verify signatue of the data using public-key
    floCrypto.verifySign = function (data, signatureHex, publicKeyHex) {
        var msgHash = Crypto.SHA256(data);
        var sigBytes = Crypto.util.hexToBytes(signatureHex);
        var publicKeyPoint = ecparams.getCurve().decodePointHex(publicKeyHex);
        var verify = Bitcoin.ECDSA.verify(msgHash, sigBytes, publicKeyPoint);
        return verify;
    }

    //Generates a new flo ID and returns private-key, public-key and floID
    const generateNewID = floCrypto.generateNewID = function () {
        var key = new Bitcoin.ECKey(false);
        key.setCompressed(true);
        return {
            floID: key.getBitcoinAddress(),
            pubKey: key.getPubKeyHex(),
            privKey: key.getBitcoinWalletImportFormat()
        }
    }

    Object.defineProperties(floCrypto, {
        newID: {
            get: () => generateNewID()
        },
        hashID: {
            value: (str) => {
                let bytes = ripemd160(Crypto.SHA256(str, { asBytes: true }), { asBytes: true });
                bytes.unshift(bitjs.pub);
                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
                    asBytes: true
                }), {
                    asBytes: true
                });
                var checksum = hash.slice(0, 4);
                return bitjs.Base58.encode(bytes.concat(checksum));
            }
        },
        tmpID: {
            get: () => {
                let bytes = Crypto.util.randomBytes(20);
                bytes.unshift(bitjs.pub);
                var hash = Crypto.SHA256(Crypto.SHA256(bytes, {
                    asBytes: true
                }), {
                    asBytes: true
                });
                var checksum = hash.slice(0, 4);
                return bitjs.Base58.encode(bytes.concat(checksum));
            }
        }
    });

    //Returns public-key from private-key
    floCrypto.getPubKeyHex = function (privateKeyHex) {
        if (!privateKeyHex)
            return null;
        var key = new Bitcoin.ECKey(privateKeyHex);
        if (key.priv == null)
            return null;
        key.setCompressed(true);
        return key.getPubKeyHex();
    }

    //Returns flo-ID from public-key or private-key
    floCrypto.getFloID = function (keyHex) {
        if (!keyHex)
            return null;
        try {
            var key = new Bitcoin.ECKey(keyHex);
            if (key.priv == null)
                key.setPub(keyHex);
            return key.getBitcoinAddress();
        } catch {
            return null;
        }
    }

    floCrypto.getAddress = function (privateKeyHex, strict = false) {
        if (!privateKeyHex)
            return;
        var key = new Bitcoin.ECKey(privateKeyHex);
        if (key.priv == null)
            return null;
        key.setCompressed(true);
        let pubKey = key.getPubKeyHex(),
            version = bitjs.Base58.decode(privateKeyHex)[0];
        switch (version) {
            case coinjs.priv: //BTC
                return coinjs.bech32Address(pubKey).address;
            case bitjs.priv: //FLO
                return bitjs.pubkey2address(pubKey);
            default:
                return strict ? false : bitjs.pubkey2address(pubKey); //default to FLO address (if strict=false)
        }
    }

    //Verify the private-key for the given public-key or flo-ID
    floCrypto.verifyPrivKey = function (privateKeyHex, pubKey_floID, isfloID = true) {
        if (!privateKeyHex || !pubKey_floID)
            return false;
        try {
            var key = new Bitcoin.ECKey(privateKeyHex);
            if (key.priv == null)
                return false;
            key.setCompressed(true);
            if (isfloID && pubKey_floID == key.getBitcoinAddress())
                return true;
            else if (!isfloID && pubKey_floID.toUpperCase() == key.getPubKeyHex().toUpperCase())
                return true;
            else
                return false;
        } catch {
            return null;
        }
    }

    floCrypto.getMultisigAddress = function (publicKeyList, requiredSignatures) {
        if (!Array.isArray(publicKeyList) || !publicKeyList.length)
            return null;
        if (!Number.isInteger(requiredSignatures) || requiredSignatures < 1 || requiredSignatures > publicKeyList.length)
            return null;
        try {
            var multisig = bitjs.pubkeys2multisig(publicKeyList, requiredSignatures);
            return multisig;
        } catch {
            return null;
        }
    }

    floCrypto.decodeRedeemScript = function (redeemScript) {
        try {
            var decoded = bitjs.transaction().decodeRedeemScript(redeemScript);
            return decoded;
        } catch {
            return null;
        }
    }

    //Check if the given flo-id is valid or not
    floCrypto.validateFloID = function (floID, regularOnly = false) {
        if (!floID)
            return false;
        try {
            let addr = new Bitcoin.Address(floID);
            if (regularOnly && addr.version != Bitcoin.Address.standardVersion)
                return false;
            return true;
        } catch {
            return false;
        }
    }

    //Check if the given address (any blockchain) is valid or not
    floCrypto.validateAddr = function (address, std = true, bech = true) {
        let raw = decodeAddress(address);
        if (!raw)
            return false;
        if (typeof raw.version !== 'undefined') { //legacy or segwit
            if (std == false)
                return false;
            else if (std === true || (!Array.isArray(std) && std === raw.version) || (Array.isArray(std) && std.includes(raw.version)))
                return true;
            else
                return false;
        } else if (typeof raw.bech_version !== 'undefined') { //bech32
            if (bech === false)
                return false;
            else if (bech === true || (!Array.isArray(bech) && bech === raw.bech_version) || (Array.isArray(bech) && bech.includes(raw.bech_version)))
                return true;
            else
                return false;
        } else //unknown
            return false;
    }

    //Check the public-key (or redeem-script) for the address (any blockchain)
    floCrypto.verifyPubKey = function (pubKeyHex, address) {
        let raw = decodeAddress(address);
        if (!raw)
            return;
        let pub_hash = Crypto.util.bytesToHex(ripemd160(Crypto.SHA256(Crypto.util.hexToBytes(pubKeyHex), { asBytes: true })));
        if (typeof raw.bech_version !== 'undefined' && raw.bytes.length == 32) //bech32-multisig
            raw.hex = Crypto.util.bytesToHex(ripemd160(raw.bytes, { asBytes: true }));
        return pub_hash === raw.hex;
    }

    //Convert the given address (any blockchain) to equivalent floID
    floCrypto.toFloID = function (address, options = null) {
        if (!address)
            return;
        let raw = decodeAddress(address);
        if (!raw)
            return;
        else if (options) { //if (optional) version check is passed
            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
                return;
            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
                return;
        }
        raw.bytes.unshift(bitjs.pub);
        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
            asBytes: true
        }), {
            asBytes: true
        });
        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
    }

    //Convert raw address bytes to floID
    floCrypto.rawToFloID = function (raw_bytes) {
        if (typeof raw_bytes === 'string')
            raw_bytes = Crypto.util.hexToBytes(raw_bytes);
        if (raw_bytes.length != 20)
            return null;
        raw_bytes.unshift(bitjs.pub);
        let hash = Crypto.SHA256(Crypto.SHA256(raw_bytes, {
            asBytes: true
        }), {
            asBytes: true
        });
        return bitjs.Base58.encode(raw_bytes.concat(hash.slice(0, 4)));
    }

    //Convert the given multisig address (any blockchain) to equivalent multisig floID
    floCrypto.toMultisigFloID = function (address, options = null) {
        if (!address)
            return;
        let raw = decodeAddress(address);
        if (!raw)
            return;
        else if (options) { //if (optional) version check is passed
            if (typeof raw.version !== 'undefined' && (!options.std || !options.std.includes(raw.version)))
                return;
            if (typeof raw.bech_version !== 'undefined' && (!options.bech || !options.bech.includes(raw.bech_version)))
                return;
        }
        if (typeof raw.bech_version !== 'undefined') {
            if (raw.bytes.length != 32) return; //multisig bech address have 32 bytes
            //multisig-bech:hash=SHA256 whereas multisig:hash=r160(SHA265), thus ripemd160 the bytes from multisig-bech
            raw.bytes = ripemd160(raw.bytes, {
                asBytes: true
            });
        }
        raw.bytes.unshift(bitjs.multisig);
        let hash = Crypto.SHA256(Crypto.SHA256(raw.bytes, {
            asBytes: true
        }), {
            asBytes: true
        });
        return bitjs.Base58.encode(raw.bytes.concat(hash.slice(0, 4)));
    }

    //Checks if the given addresses (any blockchain) are same (w.r.t keys)
    floCrypto.isSameAddr = function (addr1, addr2) {
        if (!addr1 || !addr2)
            return;
        let raw1 = decodeAddress(addr1),
            raw2 = decodeAddress(addr2);
        if (!raw1 || !raw2)
            return false;
        else {
            if (typeof raw1.bech_version !== 'undefined' && raw1.bytes.length == 32) //bech32-multisig
                raw1.hex = Crypto.util.bytesToHex(ripemd160(raw1.bytes, { asBytes: true }));
            if (typeof raw2.bech_version !== 'undefined' && raw2.bytes.length == 32) //bech32-multisig
                raw2.hex = Crypto.util.bytesToHex(ripemd160(raw2.bytes, { asBytes: true }));
            return raw1.hex === raw2.hex;
        }
    }

    const decodeAddress = floCrypto.decodeAddr = function (address) {
        if (!address)
            return;
        else if (address.length == 33 || address.length == 34) { //legacy encoding
            let decode = bitjs.Base58.decode(address);
            let bytes = decode.slice(0, decode.length - 4);
            let checksum = decode.slice(decode.length - 4),
                hash = Crypto.SHA256(Crypto.SHA256(bytes, {
                    asBytes: true
                }), {
                    asBytes: true
                });
            return (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3]) ? null : {
                version: bytes.shift(),
                hex: Crypto.util.bytesToHex(bytes),
                bytes
            }
        } else if (address.length == 42 || address.length == 62) { //bech encoding
            let decode = coinjs.bech32_decode(address);
            if (decode) {
                let bytes = decode.data;
                let bech_version = bytes.shift();
                bytes = coinjs.bech32_convert(bytes, 5, 8, false);
                return {
                    bech_version,
                    hrp: decode.hrp,
                    hex: Crypto.util.bytesToHex(bytes),
                    bytes
                }
            } else
                return null;
        }
    }

    //Split the str using shamir's Secret and Returns the shares 
    floCrypto.createShamirsSecretShares = function (str, total_shares, threshold_limit) {
        try {
            if (str.length > 0) {
                var strHex = shamirSecretShare.str2hex(str);
                var shares = shamirSecretShare.share(strHex, total_shares, threshold_limit);
                return shares;
            }
            return false;
        } catch {
            return false
        }
    }

    //Returns the retrived secret by combining the shamirs shares
    const retrieveShamirSecret = floCrypto.retrieveShamirSecret = function (sharesArray) {
        try {
            if (sharesArray.length > 0) {
                var comb = shamirSecretShare.combine(sharesArray.slice(0, sharesArray.length));
                comb = shamirSecretShare.hex2str(comb);
                return comb;
            }
            return false;
        } catch {
            return false;
        }
    }

    //Verifies the shares and str
    floCrypto.verifyShamirsSecret = function (sharesArray, str) {
        if (!str)
            return null;
        else if (retrieveShamirSecret(sharesArray) === str)
            return true;
        else
            return false;
    }

    const validateASCII = floCrypto.validateASCII = function (string, bool = true) {
        if (typeof string !== "string")
            return null;
        if (bool) {
            let x;
            for (let i = 0; i < string.length; i++) {
                x = string.charCodeAt(i);
                if (x < 32 || x > 127)
                    return false;
            }
            return true;
        } else {
            let x, invalids = {};
            for (let i = 0; i < string.length; i++) {
                x = string.charCodeAt(i);
                if (x < 32 || x > 127)
                    if (x in invalids)
                        invalids[string[i]].push(i)
                    else
                        invalids[string[i]] = [i];
            }
            if (Object.keys(invalids).length)
                return invalids;
            else
                return true;
        }
    }

    floCrypto.convertToASCII = function (string, mode = 'soft-remove') {
        let chars = validateASCII(string, false);
        if (chars === true)
            return string;
        else if (chars === null)
            return null;
        let convertor, result = string,
            refAlt = {};
        ascii_alternatives.split('\n').forEach(a => refAlt[a[0]] = a.slice(2));
        mode = mode.toLowerCase();
        if (mode === "hard-unicode")
            convertor = (c) => `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
        else if (mode === "soft-unicode")
            convertor = (c) => refAlt[c] || `\\u${('000' + c.charCodeAt().toString(16)).slice(-4)}`;
        else if (mode === "hard-remove")
            convertor = c => "";
        else if (mode === "soft-remove")
            convertor = c => refAlt[c] || "";
        else
            return null;
        for (let c in chars)
            result = result.replaceAll(c, convertor(c));
        return result;
    }

    floCrypto.revertUnicode = function (string) {
        return string.replace(/\\u[\dA-F]{4}/gi,
            m => String.fromCharCode(parseInt(m.replace(/\\u/g, ''), 16)));
    }

})('object' === typeof module ? module.exports : window.floCrypto = {});