X-Git-Url: https://git.immae.eu/?p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git;a=blobdiff_plain;f=src%2Fjs%2Findex.js;h=6367c0197fc985bc17d96a8ae15e9387effb89c8;hp=0e4cc052a4d704fa749bf9076c9bc68fc5145530;hb=32fab2c39507357909438c2be8cd100c6539038f;hpb=1b12b2f5f12b32a2ed6e69ff77f10b889b383e97

diff --git a/src/js/index.js b/src/js/index.js
index 0e4cc05..6367c01 100644
--- a/src/js/index.js
+++ b/src/js/index.js
@@ -13,15 +13,30 @@
     var showAddress = true;
     var showPubKey = true;
     var showPrivKey = true;
+    var showQr = true;
 
+    var entropyChangeTimeoutEvent = null;
     var phraseChangeTimeoutEvent = null;
     var rootKeyChangedTimeoutEvent = null;
 
     var DOM = {};
     DOM.network = $(".network");
     DOM.phraseNetwork = $("#network-phrase");
+    DOM.useEntropy = $(".use-entropy");
+    DOM.entropyContainer = $(".entropy-container");
+    DOM.entropy = $(".entropy");
+    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");
     DOM.generate = $(".generate");
     DOM.seed = $(".seed");
     DOM.rootKey = $(".root-key");
@@ -37,7 +52,7 @@
     DOM.bip44coin = $("#bip44 .coin");
     DOM.bip44account = $("#bip44 .account");
     DOM.bip44change = $("#bip44 .change");
-    DOM.strength = $(".strength");
+    DOM.generatedStrength = $(".generate-container .strength");
     DOM.hardenedAddresses = $(".hardened-addresses");
     DOM.addresses = $(".addresses");
     DOM.rowsToAdd = $(".rows-to-add");
@@ -49,10 +64,17 @@
     DOM.publicKeyToggle = $(".public-key-toggle");
     DOM.privateKeyToggle = $(".private-key-toggle");
     DOM.languages = $(".languages a");
+    DOM.qrContainer = $(".qr-container");
+    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.useEntropy.on("change", setEntropyVisibility);
+        DOM.entropy.on("input", delayedEntropyChanged);
+        DOM.entropyMnemonicLength.on("change", entropyChanged);
         DOM.phrase.on("input", delayedPhraseChanged);
         DOM.passphrase.on("input", delayedPhraseChanged);
         DOM.generate.on("click", generateClicked);
@@ -70,6 +92,7 @@
         DOM.publicKeyToggle.on("click", togglePublicKeys);
         DOM.privateKeyToggle.on("click", togglePrivateKeys);
         DOM.languages.on("click", languageChanged);
+        setQrEvents(DOM.showQrEls);
         disableForms();
         hidePending();
         hideValidationError();
@@ -89,6 +112,22 @@
         }
     }
 
+    function setEntropyVisibility() {
+        if (isUsingOwnEntropy()) {
+            DOM.entropyContainer.removeClass("hidden");
+            DOM.generateContainer.addClass("hidden");
+            DOM.phrase.prop("readonly", true);
+            DOM.entropy.focus();
+            entropyChanged();
+        }
+        else {
+            DOM.entropyContainer.addClass("hidden");
+            DOM.generateContainer.removeClass("hidden");
+            DOM.phrase.prop("readonly", false);
+            hidePending();
+        }
+    }
+
     function delayedPhraseChanged() {
         hideValidationError();
         showPending();
@@ -116,6 +155,43 @@
         hidePending();
     }
 
+    function delayedEntropyChanged() {
+        hideValidationError();
+        showPending();
+        if (entropyChangeTimeoutEvent != null) {
+            clearTimeout(entropyChangeTimeoutEvent);
+        }
+        entropyChangeTimeoutEvent = setTimeout(entropyChanged, 400);
+    }
+
+    function entropyChanged() {
+        // If blank entropy, clear mnemonic, addresses, errors
+        if (DOM.entropy.val().trim().length == 0) {
+            clearDisplay();
+            clearEntropyFeedback();
+            DOM.phrase.val("");
+            showValidationError("Blank entropy");
+            return;
+        }
+        // Get the current phrase to detect changes
+        var phrase = DOM.phrase.val();
+        // Set the phrase from the entropy
+        setMnemonicFromEntropy();
+        // Recalc addresses if the phrase has changed
+        var newPhrase = DOM.phrase.val();
+        if (newPhrase != phrase) {
+            if (newPhrase.length == 0) {
+                clearDisplay();
+            }
+            else {
+                phraseChanged();
+            }
+        }
+        else {
+            hidePending();
+        }
+    }
+
     function delayedRootKeyChanged() {
         // Warn if there is an existing mnemonic or passphrase.
         if (DOM.phrase.val().length > 0 || DOM.passphrase.val().length > 0) {
@@ -162,12 +238,15 @@
             showValidationError(errorText);
             return;
         }
-        calcBip32ExtendedKey(derivationPath);
+        bip32ExtendedKey = calcBip32ExtendedKey(derivationPath);
         displayBip32Info();
         hidePending();
     }
 
     function generateClicked() {
+        if (isUsingOwnEntropy()) {
+            return;
+        }
         clearDisplay();
         showPending();
         setTimeout(function() {
@@ -222,7 +301,7 @@
             showValidationError(errorText);
             return;
         }
-        var numWords = parseInt(DOM.strength.val());
+        var numWords = parseInt(DOM.generatedStrength.val());
         var strength = numWords / 3 * 32;
         var words = mnemonic.generate(strength);
         DOM.phrase.val(words);
@@ -239,7 +318,7 @@
     }
 
     function calcBip32ExtendedKey(path) {
-        bip32ExtendedKey = bip32RootKey;
+        var extendedKey = bip32RootKey;
         // Derive the key from the path
         var pathBits = path.split("/");
         for (var i=0; i<pathBits.length; i++) {
@@ -250,12 +329,13 @@
             }
             var hardened = bit[bit.length-1] == "'";
             if (hardened) {
-                bip32ExtendedKey = bip32ExtendedKey.deriveHardened(index);
+                extendedKey = extendedKey.deriveHardened(index);
             }
             else {
-                bip32ExtendedKey = bip32ExtendedKey.derive(index);
+                extendedKey = extendedKey.derive(index);
             }
         }
+        return extendedKey
     }
 
     function showValidationError(errorText) {
@@ -271,10 +351,13 @@
     }
 
     function findPhraseErrors(phrase) {
-        // TODO make this right
         // Preprocess the words
         phrase = mnemonic.normalizeString(phrase);
         var words = phraseToWordArray(phrase);
+        // Detect blank phrase
+        if (words.length == 0) {
+            return "Blank mnemonic";
+        }
         // Check each word
         for (var i=0; i<words.length; i++) {
             var word = words[i];
@@ -305,7 +388,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);
@@ -320,7 +403,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;
@@ -479,6 +562,8 @@
             privkeyCell.addClass("invisible");
         }
         DOM.addresses.append(row);
+        var rowShowQrEls = row.find("[data-show-qr]");
+        setQrEvents(rowShowQrEls);
     }
 
     function hasStrongRandom() {
@@ -599,7 +684,12 @@
     }
 
     function getLanguageFromUrl() {
-        return window.location.hash.substring(1);
+        for (var language in WORDLISTS) {
+            if (window.location.hash.indexOf(language) > -1) {
+                return language;
+            }
+        }
+        return "";
     }
 
     function setMnemonicLanguage() {
@@ -650,6 +740,214 @@
         return phrase;
     }
 
+    function isUsingOwnEntropy() {
+        return DOM.useEntropy.prop("checked");
+    }
+
+    function setMnemonicFromEntropy() {
+        clearEntropyFeedback();
+        // Get entropy value
+        var entropyStr = DOM.entropy.val();
+        // Work out minimum base for entropy
+        var entropy = Entropy.fromString(entropyStr);
+        if (entropy.binaryStr.length == 0) {
+            return;
+        }
+        // Show entropy details
+        showEntropyFeedback(entropy);
+        // Use entropy hash if not using raw entropy
+        var bits = entropy.binaryStr;
+        var mnemonicLength = DOM.entropyMnemonicLength.val();
+        if (mnemonicLength != "raw") {
+            // Get bits by hashing entropy with SHA256
+            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++) {
+                bits = "0" + bits;
+            }
+            // Truncate hash to suit number of words
+            mnemonicLength = parseInt(mnemonicLength);
+            var numberOfBits = 32 * mnemonicLength / 3;
+            bits = bits.substring(0, numberOfBits);
+        }
+        // Discard trailing entropy
+        var bitsToUse = Math.floor(bits.length / 32) * 32;
+        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++) {
+            var byteAsBits = binaryStr.substring(i*8, i*8+8);
+            var entropyByte = parseInt(byteAsBits, 2);
+            entropyArr.push(entropyByte)
+        }
+        // Convert entropy array to mnemonic
+        var phrase = mnemonic.toMnemonic(entropyArr);
+        // Set the mnemonic in the UI
+        DOM.phrase.val(phrase);
+    }
+
+    function clearEntropyFeedback() {
+        DOM.entropyStrength.text("...");
+        DOM.entropyType.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 (numberOfBits >= 64) {
+            strength = "very weak";
+        }
+        if (numberOfBits >= 96) {
+            strength = "weak";
+        }
+        if (numberOfBits >= 128) {
+            strength = "strong";
+        }
+        if (numberOfBits >= 160) {
+            strength = "very strong";
+        }
+        if (numberOfBits >= 192) {
+            strength = "extremely strong";
+        }
+        // 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);
+        }
+        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(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.qrImage.addClass("hidden");
+            }
+            DOM.qrContainer.removeClass("hidden");
+        }
+    }
+
+    function destroyQr() {
+        DOM.qrImage.text("");
+        DOM.qrContainer.addClass("hidden");
+    }
+
+    function toggleQr() {
+        showQr = !showQr;
+        DOM.qrImage.toggleClass("hidden");
+        DOM.qrHint.toggleClass("hidden");
+    }
+
+    function bip44TabSelected() {
+        return DOM.bip44tab.hasClass("active");
+    }
+
+    function bip32TabSelected() {
+        return DOM.bip32tab.hasClass("active");
+    }
+
     var networks = [
         {
             name: "Bitcoin",