X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=src%2Fjs%2Findex.js;h=f593b3a937a427e46511a036b1c3a311d35bd530;hb=b4fd763cebfb7f9497e12ca09b6271e1b39ac145;hp=66585a95993a64aff9921657588f8b566e2ebd4f;hpb=3599674db4855614d9123f2f80dcf0a37c34eb79;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git

diff --git a/src/js/index.js b/src/js/index.js
index 66585a9..f593b3a 100644
--- a/src/js/index.js
+++ b/src/js/index.js
@@ -3,7 +3,7 @@
     // mnemonics is populated as required by getLanguage
     var mnemonics = { "english": new Mnemonic("english") };
     var mnemonic = mnemonics["english"];
-    var seed = null
+    var seed = null;
     var bip32RootKey = null;
     var bip32ExtendedKey = null;
     var network = bitcoin.networks.bitcoin;
@@ -13,25 +13,31 @@
     var showAddress = true;
     var showPubKey = true;
     var showPrivKey = true;
+    var showQr = false;
 
     var entropyChangeTimeoutEvent = null;
     var phraseChangeTimeoutEvent = null;
     var rootKeyChangedTimeoutEvent = null;
 
+    var generationProcesses = [];
+
     var DOM = {};
     DOM.network = $(".network");
+    DOM.client = $(".client");
     DOM.phraseNetwork = $("#network-phrase");
+    DOM.phraseClient = $("#client-phrase");
     DOM.useEntropy = $(".use-entropy");
     DOM.entropyContainer = $(".entropy-container");
     DOM.entropy = $(".entropy");
-    DOM.entropyFeedback = $(".entropy-feedback");
-    DOM.entropyFiltered = DOM.entropyFeedback.find(".filtered");
-    DOM.entropyType = DOM.entropyFeedback.find(".type");
-    DOM.entropyStrength = DOM.entropyFeedback.find(".strength");
-    DOM.entropyEventCount = DOM.entropyFeedback.find(".event-count");
-    DOM.entropyBits = DOM.entropyFeedback.find(".bits");
-    DOM.entropyBitsPerEvent = DOM.entropyFeedback.find(".bits-per-event");
-    DOM.entropyMnemonicLength = DOM.entropyFeedback.find(".mnemonic-length");
+    DOM.entropyFiltered = DOM.entropyContainer.find(".filtered");
+    DOM.entropyType = DOM.entropyContainer.find(".type");
+    DOM.entropyStrength = DOM.entropyContainer.find(".strength");
+    DOM.entropyEventCount = DOM.entropyContainer.find(".event-count");
+    DOM.entropyBits = DOM.entropyContainer.find(".bits");
+    DOM.entropyBitsPerEvent = DOM.entropyContainer.find(".bits-per-event");
+    DOM.entropyWordCount = DOM.entropyContainer.find(".word-count");
+    DOM.entropyBinary = DOM.entropyContainer.find(".binary");
+    DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length");
     DOM.phrase = $(".phrase");
     DOM.passphrase = $(".passphrase");
     DOM.generateContainer = $(".generate-container");
@@ -49,6 +55,8 @@
     DOM.bip44purpose = $("#bip44 .purpose");
     DOM.bip44coin = $("#bip44 .coin");
     DOM.bip44account = $("#bip44 .account");
+    DOM.bip44accountXprv = $("#bip44 .account-xprv");
+    DOM.bip44accountXpub = $("#bip44 .account-xpub");
     DOM.bip44change = $("#bip44 .change");
     DOM.generatedStrength = $(".generate-container .strength");
     DOM.hardenedAddresses = $(".hardened-addresses");
@@ -62,10 +70,16 @@
     DOM.publicKeyToggle = $(".public-key-toggle");
     DOM.privateKeyToggle = $(".private-key-toggle");
     DOM.languages = $(".languages a");
+    DOM.qrContainer = $(".qr-container");
+    DOM.qrHider = DOM.qrContainer.find(".qr-hider");
+    DOM.qrImage = DOM.qrContainer.find(".qr-image");
+    DOM.qrHint = DOM.qrContainer.find(".qr-hint");
+    DOM.showQrEls = $("[data-show-qr]");
 
     function init() {
         // Events
         DOM.network.on("change", networkChanged);
+        DOM.client.on("change", clientChanged);
         DOM.useEntropy.on("change", setEntropyVisibility);
         DOM.entropy.on("input", delayedEntropyChanged);
         DOM.entropyMnemonicLength.on("change", entropyChanged);
@@ -86,10 +100,12 @@
         DOM.publicKeyToggle.on("click", togglePublicKeys);
         DOM.privateKeyToggle.on("click", togglePrivateKeys);
         DOM.languages.on("click", languageChanged);
+        setQrEvents(DOM.showQrEls);
         disableForms();
         hidePending();
         hideValidationError();
         populateNetworkSelect();
+        populateClientSelect();
     }
 
     // Event handlers
@@ -104,6 +120,17 @@
             rootKeyChanged();
         }
     }
+    
+    function clientChanged(e) {
+        var clientIndex = e.target.value;
+        clients[clientIndex].onSelect();
+        if (seed != null) {
+            phraseChanged();
+        }
+        else {
+            rootKeyChanged();
+        }
+    }
 
     function setEntropyVisibility() {
         if (isUsingOwnEntropy()) {
@@ -161,7 +188,7 @@
         // If blank entropy, clear mnemonic, addresses, errors
         if (DOM.entropy.val().trim().length == 0) {
             clearDisplay();
-            hideEntropyFeedback();
+            clearEntropyFeedback();
             DOM.phrase.val("");
             showValidationError("Blank entropy");
             return;
@@ -218,11 +245,11 @@
         // Calculate and display
         calcBip32RootKeyFromBase58(rootKeyBase58);
         calcForDerivationPath();
-        hidePending();
     }
 
     function calcForDerivationPath() {
         showPending();
+        clearAddressesList();
         hideValidationError();
         // Get the derivation path
         var derivationPath = getDerivationPath();
@@ -231,7 +258,10 @@
             showValidationError(errorText);
             return;
         }
-        calcBip32ExtendedKey(derivationPath);
+        bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
+        if (bip44TabSelected()) {
+            displayBip44Info();
+        }
         displayBip32Info();
         hidePending();
     }
@@ -311,7 +341,11 @@
     }
 
     function calcBip32ExtendedKey(path) {
-        bip32ExtendedKey = bip32RootKey;
+        // Check there's a root key to derive from
+        if (!bip32RootKey) {
+            return bip32RootKey;
+        }
+        var extendedKey = bip32RootKey;
         // Derive the key from the path
         var pathBits = path.split("/");
         for (var i=0; i<pathBits.length; i++) {
@@ -321,13 +355,19 @@
                 continue;
             }
             var hardened = bit[bit.length-1] == "'";
-            if (hardened) {
-                bip32ExtendedKey = bip32ExtendedKey.deriveHardened(index);
+            var isPriv = "privKey" in extendedKey;
+            var invalidDerivationPath = hardened && !isPriv;
+            if (invalidDerivationPath) {
+                extendedKey = null;
+            }
+            else if (hardened) {
+                extendedKey = extendedKey.deriveHardened(index);
             }
             else {
-                bip32ExtendedKey = bip32ExtendedKey.derive(index);
+                extendedKey = extendedKey.derive(index);
             }
         }
+        return extendedKey
     }
 
     function showValidationError(errorText) {
@@ -380,7 +420,7 @@
     }
 
     function getDerivationPath() {
-        if (DOM.bip44tab.hasClass("active")) {
+        if (bip44TabSelected()) {
             var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
             var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
             var account = parseIntNoNaN(DOM.bip44account.val(), 0);
@@ -395,7 +435,7 @@
             console.log("Using derivation path from BIP44 tab: " + derivationPath);
             return derivationPath;
         }
-        else if (DOM.bip32tab.hasClass("active")) {
+        else if (bip32TabSelected()) {
             var derivationPath = DOM.bip32path.val();
             console.log("Using derivation path from BIP32 tab: " + derivationPath);
             return derivationPath;
@@ -439,15 +479,47 @@
                 }
             }
         }
+        // Check root key exists or else derivation path is useless!
+        if (!bip32RootKey) {
+            return "No root key";
+        }
+        // Check no hardened derivation path when using xpub keys
+        var hardened = path.indexOf("'") > -1;
+        var isXpubkey = !("privKey" in bip32RootKey);
+        if (hardened && isXpubkey) {
+            return "Hardened derivation path is invalid with xpub key";
+        }
         return false;
     }
 
+    function displayBip44Info() {
+        // Get the derivation path for the account
+        var purpose = parseIntNoNaN(DOM.bip44purpose.val(), 44);
+        var coin = parseIntNoNaN(DOM.bip44coin.val(), 0);
+        var account = parseIntNoNaN(DOM.bip44account.val(), 0);
+        var path = "m/";
+        path += purpose + "'/";
+        path += coin + "'/";
+        path += account + "'/";
+        // Calculate the account extended keys
+        var accountExtendedKey = calcBip32ExtendedKey(path);
+        var accountXprv = accountExtendedKey.toBase58();
+        var accountXpub = accountExtendedKey.toBase58(false);
+        // Display the extended keys
+        DOM.bip44accountXprv.val(accountXprv);
+        DOM.bip44accountXpub.val(accountXpub);
+    }
+
     function displayBip32Info() {
         // Display the key
         DOM.seed.val(seed);
         var rootKey = bip32RootKey.toBase58();
         DOM.rootKey.val(rootKey);
-        var extendedPrivKey = bip32ExtendedKey.toBase58();
+        var xprvkeyB58 = "NA";
+        if (bip32ExtendedKey.privKey) {
+            xprvkeyB58 = bip32ExtendedKey.toBase58();
+        }
+        var extendedPrivKey = xprvkeyB58;
         DOM.extendedPrivKey.val(extendedPrivKey);
         var extendedPubKey = bip32ExtendedKey.toBase58(false);
         DOM.extendedPubKey.val(extendedPubKey);
@@ -457,14 +529,28 @@
     }
 
     function displayAddresses(start, total) {
-        for (var i=0; i<total; i++) {
-            var index = i + start;
-            new TableRow(index);
-        }
+        generationProcesses.push(new (function() {
+
+            var rows = [];
+
+            this.stop = function() {
+                for (var i=0; i<rows.length; i++) {
+                    rows[i].shouldGenerate = false;
+                }
+            }
+
+            for (var i=0; i<total; i++) {
+                var index = i + start;
+                rows.push(new TableRow(index));
+            }
+
+        })());
     }
 
     function TableRow(index) {
 
+        var self = this;
+        this.shouldGenerate = true;
         var useHardenedAddresses = DOM.hardenedAddresses.prop("checked");
 
         function init() {
@@ -473,6 +559,9 @@
 
         function calculateValues() {
             setTimeout(function() {
+                if (!self.shouldGenerate) {
+                    return;
+                }
                 var key = "";
                 if (useHardenedAddresses) {
                     key = bip32ExtendedKey.deriveHardened(index);
@@ -481,7 +570,10 @@
                     key = bip32ExtendedKey.derive(index);
                 }
                 var address = key.getAddress().toString();
-                var privkey = key.privKey.toWIF(network);
+                var privkey = "NA";
+                if (key.privKey) {
+                    privkey = key.privKey.toWIF(network);
+                }
                 var pubkey = key.pubKey.toHex();
                 var indexText = getDerivationPath() + "/" + index;
                 if (useHardenedAddresses) {
@@ -520,6 +612,14 @@
 
     function clearAddressesList() {
         DOM.addresses.empty();
+        stopGenerating();
+    }
+
+    function stopGenerating() {
+        while (generationProcesses.length > 0) {
+            var generation = generationProcesses.shift();
+            generation.stop();
+        }
     }
 
     function clearKey() {
@@ -554,6 +654,8 @@
             privkeyCell.addClass("invisible");
         }
         DOM.addresses.append(row);
+        var rowShowQrEls = row.find("[data-show-qr]");
+        setQrEvents(rowShowQrEls);
     }
 
     function hasStrongRandom() {
@@ -587,6 +689,9 @@
         var closestWord = words[0];
         for (var i=0; i<words.length; i++) {
             var comparedTo = words[i];
+            if (comparedTo.indexOf(word) == 0) {
+                return comparedTo;
+            }
             var distance = Levenshtein.get(word, comparedTo);
             if (distance < minDistance) {
                 closestWord = comparedTo;
@@ -611,6 +716,16 @@
             DOM.phraseNetwork.append(option);
         }
     }
+    
+    function populateClientSelect() {
+        for (var i=0; i<clients.length; i++) {
+            var client = clients[i];
+            var option = $("<option>");
+            option.attr("value", i);
+            option.text(client.name);
+            DOM.phraseClient.append(option);
+        }
+    }
 
     function getLanguage() {
         var defaultLanguage = "english";
@@ -735,7 +850,7 @@
     }
 
     function setMnemonicFromEntropy() {
-        hideEntropyFeedback();
+        clearEntropyFeedback();
         // Get entropy value
         var entropyStr = DOM.entropy.val();
         // Work out minimum base for entropy
@@ -753,7 +868,7 @@
             var hash = sjcl.hash.sha256.hash(entropy.cleanStr);
             var hex = sjcl.codec.hex.fromBits(hash);
             bits = BigInteger.parse(hex, 16).toString(2);
-            for (var i=0; i<256-bits.length; i++) {
+            while (bits.length % 256 != 0) {
                 bits = "0" + bits;
             }
             // Truncate hash to suit number of words
@@ -763,7 +878,8 @@
         }
         // Discard trailing entropy
         var bitsToUse = Math.floor(bits.length / 32) * 32;
-        var binaryStr = bits.substring(0, bitsToUse);
+        var start = bits.length - bitsToUse;
+        var binaryStr = bits.substring(start);
         // Convert entropy string to numeric array
         var entropyArr = [];
         for (var i=0; i<binaryStr.length / 8; i++) {
@@ -777,44 +893,167 @@
         DOM.phrase.val(phrase);
     }
 
-    function hideEntropyFeedback() {
-        DOM.entropyFeedback.addClass("hidden");
-        DOM.entropyFiltered.text("");
+    function clearEntropyFeedback() {
+        DOM.entropyStrength.text("...");
         DOM.entropyType.text("");
-        DOM.entropyStrength.text("");
-        DOM.entropyEventCount.text("");
-        DOM.entropyBits.text("");
-        DOM.entropyBitsPerEvent.text("");
+        DOM.entropyWordCount.text("0");
+        DOM.entropyEventCount.text("0");
+        DOM.entropyBitsPerEvent.text("0");
+        DOM.entropyBits.text("0");
+        DOM.entropyFiltered.html("&nbsp;");
+        DOM.entropyBinary.html("&nbsp;");
     }
 
     function showEntropyFeedback(entropy) {
+        var numberOfBits = entropy.binaryStr.length;
         var strength = "extremely weak";
-        if (entropy.binaryStr.length >= 64) {
+        if (numberOfBits >= 64) {
             strength = "very weak";
         }
-        if (entropy.binaryStr.length >= 96) {
+        if (numberOfBits >= 96) {
             strength = "weak";
         }
-        if (entropy.binaryStr.length >= 128) {
+        if (numberOfBits >= 128) {
             strength = "strong";
         }
-        if (entropy.binaryStr.length >= 160) {
+        if (numberOfBits >= 160) {
             strength = "very strong";
         }
-        if (entropy.binaryStr.length >= 192) {
+        if (numberOfBits >= 192) {
             strength = "extremely strong";
         }
-        var bitsStr = entropy.binaryStr.length;
-        if (entropy.base.asInt != 2) {
-            bitsStr += " (" + entropy.binaryStr + ")";
+        // If time to crack is less than one day, and password is considered
+        // strong or better based on the number of bits, rename strength to
+        // 'easily cracked'.
+        try {
+            var z = zxcvbn(entropy.base.parts.join(""));
+            var timeToCrack = z.crack_times_seconds.offline_fast_hashing_1e10_per_second;
+            if (timeToCrack < 86400 && entropy.binaryStr.length >= 128) {
+                strength = "easily cracked";
+                if (z.feedback.warning != "") {
+                    strength = strength + " - " + z.feedback.warning;
+                };
+            }
+        }
+        catch (e) {
+            strength = "unknown";
+            console.log("Error detecting entropy strength with zxcvbn:");
+            console.log(e);
         }
-        DOM.entropyFiltered.text(entropy.cleanStr);
-        DOM.entropyType.text(entropy.base.str);
+        var entropyTypeStr = getEntropyTypeStr(entropy);
+        var wordCount = Math.floor(numberOfBits / 32) * 3;
+        var bitsPerEvent = entropy.bitsPerEvent.toFixed(2);
+        DOM.entropyFiltered.html(entropy.cleanHtml);
+        DOM.entropyType.text(entropyTypeStr);
         DOM.entropyStrength.text(strength);
         DOM.entropyEventCount.text(entropy.base.ints.length);
-        DOM.entropyBits.text(bitsStr);
-        DOM.entropyBitsPerEvent.text(Math.log2(entropy.base.asInt).toFixed(2));
-        DOM.entropyFeedback.removeClass("hidden");
+        DOM.entropyBits.text(numberOfBits);
+        DOM.entropyWordCount.text(wordCount);
+        DOM.entropyBinary.text(entropy.binaryStr);
+        DOM.entropyBitsPerEvent.text(bitsPerEvent);
+    }
+
+    function getEntropyTypeStr(entropy) {
+        var typeStr = entropy.base.str;
+        // Add some detail if these are cards
+        if (entropy.base.asInt == 52) {
+            var cardDetail = []; // array of message strings
+            // Detect duplicates
+            var dupes = [];
+            var dupeTracker = {};
+            for (var i=0; i<entropy.base.parts.length; i++) {
+                var card = entropy.base.parts[i];
+                var cardUpper = card.toUpperCase();
+                if (cardUpper in dupeTracker) {
+                    dupes.push(card);
+                }
+                dupeTracker[cardUpper] = true;
+            }
+            if (dupes.length > 0) {
+                var dupeWord = "duplicates";
+                if (dupes.length == 1) {
+                    dupeWord = "duplicate";
+                }
+                var msg = dupes.length + " " + dupeWord + ": " + dupes.slice(0,3).join(" ");
+                if (dupes.length > 3) {
+                    msg += "...";
+                }
+                cardDetail.push(msg);
+            }
+            // Detect full deck
+            var uniqueCards = [];
+            for (var uniqueCard in dupeTracker) {
+                uniqueCards.push(uniqueCard);
+            }
+            if (uniqueCards.length == 52) {
+                cardDetail.unshift("full deck");
+            }
+            // Detect missing cards
+            var values = "A23456789TJQK";
+            var suits = "CDHS";
+            var missingCards = [];
+            for (var i=0; i<suits.length; i++) {
+                for (var j=0; j<values.length; j++) {
+                    var card = values[j] + suits[i];
+                    if (!(card in dupeTracker)) {
+                        missingCards.push(card);
+                    }
+                }
+            }
+            // Display missing cards if six or less, ie clearly going for full deck
+            if (missingCards.length > 0 && missingCards.length <= 6) {
+                var msg = missingCards.length + " missing: " + missingCards.slice(0,3).join(" ");
+                if (missingCards.length > 3) {
+                    msg += "...";
+                }
+                cardDetail.push(msg);
+            }
+            // Add card details to typeStr
+            if (cardDetail.length > 0) {
+                typeStr += " (" + cardDetail.join(", ") + ")";
+            }
+        }
+        return typeStr;
+    }
+
+    function setQrEvents(els) {
+        els.on("mouseenter", createQr);
+        els.on("mouseleave", destroyQr);
+        els.on("click", toggleQr);
+    }
+
+    function createQr(e) {
+        var content = e.target.textContent || e.target.value;
+        if (content) {
+            var size = 130;
+            DOM.qrImage.qrcode({width: size, height: size, text: content});
+            if (!showQr) {
+                DOM.qrHider.addClass("hidden");
+            }
+            else {
+                DOM.qrHider.removeClass("hidden");
+            }
+            DOM.qrContainer.removeClass("hidden");
+        }
+    }
+
+    function destroyQr() {
+        DOM.qrImage.text("");
+        DOM.qrContainer.addClass("hidden");
+    }
+
+    function toggleQr() {
+        showQr = !showQr;
+        DOM.qrHider.toggleClass("hidden");
+        DOM.qrHint.toggleClass("hidden");
+    }
+
+    function bip44TabSelected() {
+        return DOM.bip44tab.hasClass("active");
+    }
+
+    function bip32TabSelected() {
+        return DOM.bip32tab.hasClass("active");
     }
 
     var networks = [
@@ -910,6 +1149,30 @@
             },
         },
     ]
+    
+    var clients = [
+        {
+            name: "Bitcoin Core",
+            onSelect: function() {
+                DOM.bip32path.val("m/0'/0'");
+                DOM.hardenedAddresses.prop('checked', true);
+            },
+        },
+        {
+            name: "blockchain.info",
+            onSelect: function() {
+                DOM.bip32path.val("m/44'/0'/0'");
+                DOM.hardenedAddresses.prop('checked', false);
+            },
+        },
+        {
+            name: "MultiBit HD",
+            onSelect: function() {
+                DOM.bip32path.val("m/0'/0");
+                DOM.hardenedAddresses.prop('checked', false);
+            },
+        }
+    ]
 
     init();