X-Git-Url: https://git.immae.eu/?p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git;a=blobdiff_plain;f=src%2Fjs%2Findex.js;h=a147f61df8550bccec7013f7e698d7df3613d224;hp=3690de1c6cdbde5bca14d5459542cc24ee8b3ecb;hb=4735db1064dc75b71e93eedafa988db037687c93;hpb=b299a6a722ef43caf80bf1be8a47a020cc740d4c diff --git a/src/js/index.js b/src/js/index.js index 3690de1..dea2ceb 100644 --- a/src/js/index.js +++ b/src/js/index.js @@ -3,58 +3,107 @@ // 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; + var network = bitcoinjs.bitcoin.networks.bitcoin; var addressRowTemplate = $("#address-row-template"); var showIndex = true; var showAddress = true; var showPubKey = true; var showPrivKey = true; + var showQr = false; + var litecoinUseLtub = true; var entropyChangeTimeoutEvent = null; var phraseChangeTimeoutEvent = null; var rootKeyChangedTimeoutEvent = null; + var generationProcesses = []; + var DOM = {}; + DOM.privacyScreenToggle = $(".privacy-screen-toggle"); DOM.network = $(".network"); + DOM.bip32Client = $("#bip32-client"); DOM.phraseNetwork = $("#network-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.entropyCrackTime = DOM.entropyContainer.find(".crack-time"); + 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.entropyWordIndexes = DOM.entropyContainer.find(".word-indexes"); + DOM.entropyChecksum = DOM.entropyContainer.find(".checksum"); + DOM.entropyMnemonicLength = DOM.entropyContainer.find(".mnemonic-length"); + DOM.entropyWeakEntropyOverrideWarning = DOM.entropyContainer.find(".weak-entropy-override-warning"); + DOM.entropyFilterWarning = DOM.entropyContainer.find(".filter-warning"); DOM.phrase = $(".phrase"); DOM.passphrase = $(".passphrase"); DOM.generateContainer = $(".generate-container"); DOM.generate = $(".generate"); DOM.seed = $(".seed"); DOM.rootKey = $(".root-key"); + DOM.litecoinLtubContainer = $(".litecoin-ltub-container"); + DOM.litecoinUseLtub = $(".litecoin-use-ltub"); DOM.extendedPrivKey = $(".extended-priv-key"); DOM.extendedPubKey = $(".extended-pub-key"); DOM.bip32tab = $("#bip32-tab"); DOM.bip44tab = $("#bip44-tab"); + DOM.bip49tab = $("#bip49-tab"); + DOM.bip84tab = $("#bip84-tab"); + DOM.bip141tab = $("#bip141-tab"); DOM.bip32panel = $("#bip32"); DOM.bip44panel = $("#bip44"); + DOM.bip49panel = $("#bip49"); DOM.bip32path = $("#bip32-path"); DOM.bip44path = $("#bip44-path"); 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.bip49unavailable = $("#bip49 .unavailable"); + DOM.bip49available = $("#bip49 .available"); + DOM.bip49path = $("#bip49-path"); + DOM.bip49purpose = $("#bip49 .purpose"); + DOM.bip49coin = $("#bip49 .coin"); + DOM.bip49account = $("#bip49 .account"); + DOM.bip49accountXprv = $("#bip49 .account-xprv"); + DOM.bip49accountXpub = $("#bip49 .account-xpub"); + DOM.bip49change = $("#bip49 .change"); + DOM.bip84unavailable = $("#bip84 .unavailable"); + DOM.bip84available = $("#bip84 .available"); + DOM.bip84path = $("#bip84-path"); + DOM.bip84purpose = $("#bip84 .purpose"); + DOM.bip84coin = $("#bip84 .coin"); + DOM.bip84account = $("#bip84 .account"); + DOM.bip84accountXprv = $("#bip84 .account-xprv"); + DOM.bip84accountXpub = $("#bip84 .account-xpub"); + DOM.bip84change = $("#bip84 .change"); + DOM.bip141unavailable = $("#bip141 .unavailable"); + DOM.bip141available = $("#bip141 .available"); + DOM.bip141path = $("#bip141-path"); + DOM.bip141semantics = $(".bip141-semantics"); DOM.generatedStrength = $(".generate-container .strength"); + DOM.generatedStrengthWarning = $(".generate-container .warning"); DOM.hardenedAddresses = $(".hardened-addresses"); + DOM.bitcoinCashAddressTypeContainer = $(".bch-addr-type-container"); + DOM.bitcoinCashAddressType = $("[name=bch-addr-type]") + DOM.useBip38 = $(".use-bip38"); + DOM.bip38Password = $(".bip38-password"); DOM.addresses = $(".addresses"); + DOM.csvTab = $("#csv-tab a"); + DOM.csv = $(".csv"); DOM.rowsToAdd = $(".rows-to-add"); DOM.more = $(".more"); + DOM.moreRowsStartIndex = $(".more-rows-start-index"); DOM.feedback = $(".feedback"); DOM.tab = $(".derivation-type a"); DOM.indexToggle = $(".index-toggle"); @@ -62,10 +111,18 @@ 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.privacyScreenToggle.on("change", privacyScreenToggled); + DOM.generatedStrength.on("change", generatedStrengthChanged); DOM.network.on("change", networkChanged); + DOM.bip32Client.on("change", bip32ClientChanged); DOM.useEntropy.on("change", setEntropyVisibility); DOM.entropy.on("input", delayedEntropyChanged); DOM.entropyMnemonicLength.on("change", entropyChanged); @@ -74,29 +131,56 @@ DOM.generate.on("click", generateClicked); DOM.more.on("click", showMore); DOM.rootKey.on("input", delayedRootKeyChanged); + DOM.litecoinUseLtub.on("change", litecoinUseLtubChanged); DOM.bip32path.on("input", calcForDerivationPath); - DOM.bip44purpose.on("input", calcForDerivationPath); - DOM.bip44coin.on("input", calcForDerivationPath); DOM.bip44account.on("input", calcForDerivationPath); DOM.bip44change.on("input", calcForDerivationPath); - DOM.tab.on("shown.bs.tab", calcForDerivationPath); + DOM.bip49account.on("input", calcForDerivationPath); + DOM.bip49change.on("input", calcForDerivationPath); + DOM.bip84account.on("input", calcForDerivationPath); + DOM.bip84change.on("input", calcForDerivationPath); + DOM.bip141path.on("input", calcForDerivationPath); + DOM.bip141semantics.on("change", tabChanged); + DOM.tab.on("shown.bs.tab", tabChanged); DOM.hardenedAddresses.on("change", calcForDerivationPath); + DOM.useBip38.on("change", calcForDerivationPath); + DOM.bip38Password.on("change", calcForDerivationPath); DOM.indexToggle.on("click", toggleIndexes); DOM.addressToggle.on("click", toggleAddresses); DOM.publicKeyToggle.on("click", togglePublicKeys); DOM.privateKeyToggle.on("click", togglePrivateKeys); + DOM.csvTab.on("click", updateCsv); DOM.languages.on("click", languageChanged); + DOM.bitcoinCashAddressType.on("change", bitcoinCashAddressTypeChange); + setQrEvents(DOM.showQrEls); disableForms(); hidePending(); hideValidationError(); populateNetworkSelect(); + populateClientSelect(); } // Event handlers + function generatedStrengthChanged() { + var strength = parseInt(DOM.generatedStrength.val()); + if (strength < 12) { + DOM.generatedStrengthWarning.removeClass("hidden"); + } + else { + DOM.generatedStrengthWarning.addClass("hidden"); + } + } + function networkChanged(e) { + clearDerivedKeys(); + clearAddressesList(); + DOM.litecoinLtubContainer.addClass("hidden"); + DOM.bitcoinCashAddressTypeContainer.addClass("hidden"); var networkIndex = e.target.value; - networks[networkIndex].onSelect(); + var network = networks[networkIndex]; + network.onSelect(); + adjustNetworkForSegwit(); if (seed != null) { phraseChanged(); } @@ -105,6 +189,23 @@ } } + function bip32ClientChanged(e) { + var clientIndex = DOM.bip32Client.val(); + if (clientIndex == "custom") { + DOM.bip32path.prop("readonly", false); + } + else { + DOM.bip32path.prop("readonly", true); + clients[clientIndex].onSelect(); + if (seed != null) { + phraseChanged(); + } + else { + rootKeyChanged(); + } + } + } + function setEntropyVisibility() { if (isUsingOwnEntropy()) { DOM.entropyContainer.removeClass("hidden"); @@ -123,6 +224,10 @@ function delayedPhraseChanged() { hideValidationError(); + seed = null; + bip32RootKey = null; + bip32ExtendedKey = null; + clearAddressesList(); showPending(); if (phraseChangeTimeoutEvent != null) { clearTimeout(phraseChangeTimeoutEvent); @@ -132,7 +237,6 @@ function phraseChanged() { showPending(); - hideValidationError(); setMnemonicLanguage(); // Get the mnemonic phrase var phrase = DOM.phrase.val(); @@ -145,7 +249,37 @@ var passphrase = DOM.passphrase.val(); calcBip32RootKeyFromSeed(phrase, passphrase); calcForDerivationPath(); - hidePending(); + // Show the word indexes + showWordIndexes(); + } + + function tabChanged() { + showPending(); + adjustNetworkForSegwit(); + var phrase = DOM.phrase.val(); + if (phrase != "") { + // Calculate and display for mnemonic + var errorText = findPhraseErrors(phrase); + if (errorText) { + showValidationError(errorText); + return; + } + // Calculate and display + var passphrase = DOM.passphrase.val(); + calcBip32RootKeyFromSeed(phrase, passphrase); + } + else { + // Calculate and display for root key + var rootKeyBase58 = DOM.rootKey.val(); + var errorText = validateRootKey(rootKeyBase58); + if (errorText) { + showValidationError(errorText); + return; + } + // Calculate and display + calcBip32RootKeyFromBase58(rootKeyBase58); + } + calcForDerivationPath(); } function delayedEntropyChanged() { @@ -161,7 +295,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; @@ -208,7 +342,6 @@ function rootKeyChanged() { showPending(); hideValidationError(); - // Validate the root key TODO var rootKeyBase58 = DOM.rootKey.val(); var errorText = validateRootKey(rootKeyBase58); if (errorText) { @@ -218,12 +351,30 @@ // Calculate and display calcBip32RootKeyFromBase58(rootKeyBase58); calcForDerivationPath(); - hidePending(); + } + + function litecoinUseLtubChanged() { + litecoinUseLtub = DOM.litecoinUseLtub.prop("checked"); + if (litecoinUseLtub) { + network = bitcoinjs.bitcoin.networks.litecoin; + } + else { + network = bitcoinjs.bitcoin.networks.litecoinXprv; + } + phraseChanged(); } function calcForDerivationPath() { + clearDerivedKeys(); + clearAddressesList(); showPending(); - hideValidationError(); + // Don't show segwit if it's selected but network doesn't support it + if (segwitSelected() && !networkHasSegwit()) { + showSegwitUnavailable(); + hidePending(); + return; + } + showSegwitAvailable(); // Get the derivation path var derivationPath = getDerivationPath(); var errorText = findDerivationPathErrors(derivationPath); @@ -231,9 +382,17 @@ showValidationError(errorText); return; } - calcBip32ExtendedKey(derivationPath); + bip32ExtendedKey = calcBip32ExtendedKey(derivationPath); + if (bip44TabSelected()) { + displayBip44Info(); + } + else if (bip49TabSelected()) { + displayBip49Info(); + } + else if (bip84TabSelected()) { + displayBip84Info(); + } displayBip32Info(); - hidePending(); } function generateClicked() { @@ -266,6 +425,10 @@ }, 50); } + function bitcoinCashAddressTypeChange() { + phraseChanged(); + } + function toggleIndexes() { showIndex = !showIndex; $("td.index span").toggleClass("invisible"); @@ -286,6 +449,17 @@ $("td.privkey span").toggleClass("invisible"); } + function privacyScreenToggled() { + // private-data contains elements added to DOM at runtime + // so catch all by adding visual privacy class to the root of the DOM + if (DOM.privacyScreenToggle.prop("checked")) { + $("body").addClass("visual-privacy"); + } + else { + $("body").removeClass("visual-privacy"); + } + } + // Private methods function generateRandomPhrase() { @@ -294,24 +468,69 @@ showValidationError(errorText); return; } + // get the amount of entropy to use var numWords = parseInt(DOM.generatedStrength.val()); var strength = numWords / 3 * 32; - var words = mnemonic.generate(strength); + var buffer = new Uint8Array(strength / 8); + // create secure entropy + var data = crypto.getRandomValues(buffer); + // show the words + var words = mnemonic.toMnemonic(data); DOM.phrase.val(words); + // show the entropy + var entropyHex = uint8ArrayToHex(data); + DOM.entropy.val(entropyHex); + // ensure entropy fields are consistent with what is being displayed + DOM.entropyMnemonicLength.val("raw"); return words; } function calcBip32RootKeyFromSeed(phrase, passphrase) { seed = mnemonic.toSeed(phrase, passphrase); - bip32RootKey = bitcoin.HDNode.fromSeedHex(seed, network); + bip32RootKey = bitcoinjs.bitcoin.HDNode.fromSeedHex(seed, network); } function calcBip32RootKeyFromBase58(rootKeyBase58) { - bip32RootKey = bitcoin.HDNode.fromBase58(rootKeyBase58, network); + // try parsing with various segwit network params since this extended + // key may be from any one of them. + if (networkHasSegwit()) { + var n = network; + if ("baseNetwork" in n) { + n = bitcoinjs.bitcoin.networks[n.baseNetwork]; + } + // try parsing using base network params + try { + bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n); + return; + } + catch (e) {} + // try parsing using p2wpkh params + if ("p2wpkh" in n) { + try { + bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkh); + return; + } + catch (e) {} + } + // try parsing using p2wpkh-in-p2sh network params + if ("p2wpkhInP2sh" in n) { + try { + bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, n.p2wpkhInP2sh); + return; + } + catch (e) {} + } + } + // try the network params as currently specified + bip32RootKey = bitcoinjs.bitcoin.HDNode.fromBase58(rootKeyBase58, network); } 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 -1; + var hardenedAddresses = bip32TabSelected() && DOM.hardenedAddresses.prop("checked"); + var hardened = hardenedPath || hardenedAddresses; + var isXpubkey = bip32RootKey.isNeutered(); + 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.neutered().toBase58(); + // Display the extended keys + DOM.bip44accountXprv.val(accountXprv); + DOM.bip44accountXpub.val(accountXpub); + } + + function displayBip49Info() { + // Get the derivation path for the account + var purpose = parseIntNoNaN(DOM.bip49purpose.val(), 49); + var coin = parseIntNoNaN(DOM.bip49coin.val(), 0); + var account = parseIntNoNaN(DOM.bip49account.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.neutered().toBase58(); + // Display the extended keys + DOM.bip49accountXprv.val(accountXprv); + DOM.bip49accountXpub.val(accountXpub); + } + + function displayBip84Info() { + // Get the derivation path for the account + var purpose = parseIntNoNaN(DOM.bip84purpose.val(), 84); + var coin = parseIntNoNaN(DOM.bip84coin.val(), 0); + var account = parseIntNoNaN(DOM.bip84account.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.neutered().toBase58(); + // Display the extended keys + DOM.bip84accountXprv.val(accountXprv); + DOM.bip84accountXpub.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.isNeutered()) { + xprvkeyB58 = bip32ExtendedKey.toBase58(); + } + var extendedPrivKey = xprvkeyB58; DOM.extendedPrivKey.val(extendedPrivKey); - var extendedPubKey = bip32ExtendedKey.toBase58(false); + var extendedPubKey = bip32ExtendedKey.neutered().toBase58(); DOM.extendedPubKey.val(extendedPubKey); // Display the addresses and privkeys clearAddressesList(); - displayAddresses(0, 20); + var initialAddressCount = parseInt(DOM.rowsToAdd.val()); + displayAddresses(0, initialAddressCount); } function displayAddresses(start, total) { - for (var i=0; i 200) { var msg = "Generating " + rowsToAdd + " rows could take a while. "; msg += "Do you want to continue?"; @@ -514,18 +998,37 @@ function clearDisplay() { clearAddressesList(); - clearKey(); + clearKeys(); hideValidationError(); } function clearAddressesList() { DOM.addresses.empty(); + DOM.csv.val(""); + stopGenerating(); + } + + function stopGenerating() { + while (generationProcesses.length > 0) { + var generation = generationProcesses.shift(); + generation.stop(); + } + } + + function clearKeys() { + clearRootKey(); + clearDerivedKeys(); } - function clearKey() { + function clearRootKey() { DOM.rootKey.val(""); + } + + function clearDerivedKeys() { DOM.extendedPrivKey.val(""); DOM.extendedPubKey.val(""); + DOM.bip44accountXprv.val(""); + DOM.bip44accountXpub.val(""); } function addAddressToList(indexText, address, pubkey, privkey) { @@ -554,6 +1057,8 @@ privkeyCell.addClass("invisible"); } DOM.addresses.append(row); + var rowShowQrEls = row.find("[data-show-qr]"); + setQrEvents(rowShowQrEls); } function hasStrongRandom() { @@ -587,6 +1092,9 @@ var closestWord = words[0]; for (var i=0; i"); option.attr("value", i); option.text(network.name); + if (network.name == "BTC - Bitcoin") { + option.prop("selected", true); + } DOM.phraseNetwork.append(option); } } + function populateClientSelect() { + for (var i=0; i"); + option.attr("value", i); + option.text(client.name); + DOM.bip32Client.append(option); + } + } + function getLanguage() { var defaultLanguage = "english"; // Try to get from existing phrase @@ -735,7 +1256,7 @@ } function setMnemonicFromEntropy() { - hideEntropyFeedback(); + clearEntropyFeedback(); // Get entropy value var entropyStr = DOM.entropy.val(); // Work out minimum base for entropy @@ -753,17 +1274,29 @@ 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 mnemonicLength = parseInt(mnemonicLength); var numberOfBits = 32 * mnemonicLength / 3; bits = bits.substring(0, numberOfBits); + // show warning for weak entropy override + if (mnemonicLength / 3 * 32 > entropy.binaryStr.length) { + DOM.entropyWeakEntropyOverrideWarning.removeClass("hidden"); + } + else { + DOM.entropyWeakEntropyOverrideWarning.addClass("hidden"); + } + } + else { + // hide warning for weak entropy override + DOM.entropyWeakEntropyOverrideWarning.addClass("hidden"); } // 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= 64) { - strength = "very weak"; + var numberOfBits = entropy.binaryStr.length; + var timeToCrack = "unknown"; + try { + var z = zxcvbn(entropy.base.parts.join("")); + timeToCrack = z.crack_times_display.offline_fast_hashing_1e10_per_second; + if (z.feedback.warning != "") { + timeToCrack = timeToCrack + " - " + z.feedback.warning; + }; + } + catch (e) { + 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); + var spacedBinaryStr = addSpacesEveryElevenBits(entropy.binaryStr); + DOM.entropyFiltered.html(entropy.cleanHtml); + DOM.entropyType.text(entropyTypeStr); + DOM.entropyCrackTime.text(timeToCrack); + DOM.entropyEventCount.text(entropy.base.ints.length); + DOM.entropyBits.text(numberOfBits); + DOM.entropyWordCount.text(wordCount); + DOM.entropyBinary.text(spacedBinaryStr); + DOM.entropyBitsPerEvent.text(bitsPerEvent); + // detect and warn of filtering + var rawNoSpaces = DOM.entropy.val().replace(/\s/g, ""); + var cleanNoSpaces = entropy.cleanStr.replace(/\s/g, ""); + var isFiltered = rawNoSpaces.length != cleanNoSpaces.length; + if (isFiltered) { + DOM.entropyFilterWarning.removeClass('hidden'); } - if (entropy.binaryStr.length >= 96) { - strength = "weak"; + else { + DOM.entropyFilterWarning.addClass('hidden'); } - if (entropy.binaryStr.length >= 128) { - strength = "strong"; + } + + 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 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 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(", ") + ")"; + } } - if (entropy.binaryStr.length >= 160) { - strength = "very strong"; + 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 qrEl = kjua({ + text: content, + render: "canvas", + size: 310, + ecLevel: 'H', + }); + DOM.qrImage.append(qrEl); + if (!showQr) { + DOM.qrHider.addClass("hidden"); + } + else { + DOM.qrHider.removeClass("hidden"); + } + DOM.qrContainer.removeClass("hidden"); } - if (entropy.binaryStr.length >= 192) { - strength = "extremely strong"; + } + + 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"); + } + + function networkHasSegwit() { + var n = network; + if ("baseNetwork" in network) { + n = bitcoinjs.bitcoin.networks[network.baseNetwork]; } - // 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'. - var z = zxcvbn(entropy.cleanStr); - 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; - }; + // check if only p2wpkh params are required + if (p2wpkhSelected()) { + return "p2wpkh" in n; } - var bitsStr = entropy.binaryStr.length; - if (entropy.base.asInt != 2) { - bitsStr += " (" + entropy.binaryStr + ")"; + // check if only p2wpkh-in-p2sh params are required + else if (p2wpkhInP2shSelected()) { + return "p2wpkhInP2sh" in n; } - DOM.entropyFiltered.text(entropy.cleanStr); - DOM.entropyType.text(entropy.base.str); - 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"); + // require both if it's unclear which params are required + return "p2wpkh" in n && "p2wpkhInP2sh" in n; + } + + function bip49TabSelected() { + return DOM.bip49tab.hasClass("active"); + } + + function bip84TabSelected() { + return DOM.bip84tab.hasClass("active"); + } + + function bip141TabSelected() { + return DOM.bip141tab.hasClass("active"); + } + + function setHdCoin(coinValue) { + DOM.bip44coin.val(coinValue); + DOM.bip49coin.val(coinValue); + DOM.bip84coin.val(coinValue); + } + + function showSegwitAvailable() { + DOM.bip49unavailable.addClass("hidden"); + DOM.bip49available.removeClass("hidden"); + DOM.bip84unavailable.addClass("hidden"); + DOM.bip84available.removeClass("hidden"); + DOM.bip141unavailable.addClass("hidden"); + DOM.bip141available.removeClass("hidden"); + } + + function showSegwitUnavailable() { + DOM.bip49available.addClass("hidden"); + DOM.bip49unavailable.removeClass("hidden"); + DOM.bip84available.addClass("hidden"); + DOM.bip84unavailable.removeClass("hidden"); + DOM.bip141available.addClass("hidden"); + DOM.bip141unavailable.removeClass("hidden"); + } + + function adjustNetworkForSegwit() { + // If segwit is selected the xpub/xprv prefixes need to be adjusted + // to avoid accidentally importing BIP49 xpub to BIP44 watch only + // wallet. + // See https://github.com/iancoleman/bip39/issues/125 + var segwitNetworks = null; + // if a segwit network is alread selected, need to use base network to + // look up new parameters + if ("baseNetwork" in network) { + network = bitcoinjs.bitcoin.networks[network.baseNetwork]; + } + // choose the right segwit params + if (p2wpkhSelected() && "p2wpkh" in network) { + network = network.p2wpkh; + } + else if (p2wpkhInP2shSelected() && "p2wpkhInP2sh" in network) { + network = network.p2wpkhInP2sh; + } + } + + function lastIndexInTable() { + var pathText = DOM.addresses.find(".index").last().text(); + var pathBits = pathText.split("/"); + var lastBit = pathBits[pathBits.length-1]; + var lastBitClean = lastBit.replace("'", ""); + return parseInt(lastBitClean); + } + + function uint8ArrayToHex(a) { + var s = "" + for (var i=0; i=0; i--) { + var word = words[i]; + var wordIndex = WORDLISTS[language].indexOf(word); + var wordBinary = wordIndex.toString(2); + while (wordBinary.length < 11) { + wordBinary = "0" + wordBinary; + } + var binaryStr = wordBinary + binaryStr; + if (binaryStr.length >= checksumBitlength) { + var start = binaryStr.length - checksumBitlength; + var end = binaryStr.length; + checksum = binaryStr.substring(start, end); + // add spaces so the last group is 11 bits, not the first + checksum = checksum.split("").reverse().join("") + checksum = addSpacesEveryElevenBits(checksum); + checksum = checksum.split("").reverse().join("") + break; + } + } + DOM.entropyChecksum.text(checksum); + } + + function updateCsv() { + var tableCsv = "path,address,public key,private key\n"; + var rows = DOM.addresses.find("tr"); + for (var i=0; i