<select class="mnemonic-length form-control">
<option value="raw">From entropy length (3 words per 32 bits)</option>
<option value="12">12 Words</option>
- <option value="15">15 Words</option>
+ <option value="15" selected>15 Words</option>
<option value="18">18 Words</option>
<option value="21">21 Words</option>
<option value="24">24 Words</option>
* dice 6 [1-6]
* decimal [0-9]
* hexadecimal [0-9A-F]
+ * card [A2-9TJQK][CDHS]
*
* Automatically uses lowest entropy to avoid issues such as interpretting 0101
* as hexadecimal which would be 16 bits when really it's only 4 bits of binary
window.Entropy = new (function() {
+ var TWO = new BigInteger(2);
+
// matchers returns an array of the matched events for each type of entropy.
// eg
// matchers.binary("010") returns ["0", "1", "0"]
while (entropyBin.length < expectedBits) {
entropyBin = "0" + entropyBin;
}
+ // Assume cards are NOT replaced.
+ // Additional entropy decreases as more cards are used. This means
+ // total possible entropy is measured using n!, not base^n.
+ // eg the second last card can be only one of two, not one of fifty two
+ // so the added entropy for that card is only one bit at most
+ if (base.asInt == 52) {
+ var totalDecks = Math.ceil(base.parts.length / 52);
+ var totalCards = totalDecks * 52;
+ var totalCombos = factorial(52).pow(totalDecks);
+ var totalRemainingCards = totalCards - base.parts.length;
+ var remainingDecks = Math.floor(totalRemainingCards / 52);
+ var remainingCards = totalRemainingCards % 52;
+ var remainingCombos = factorial(52).pow(remainingDecks).multiply(factorial(remainingCards));
+ var currentCombos = totalCombos.divide(remainingCombos);
+ var numberOfBits = Math.log2(currentCombos);
+ var maxWithoutReplace = BigInteger.pow(2, numberOfBits);
+ // Use a bunch of sorted decks to measure entropy from, populated
+ // as needed.
+ var sortedDecks = [];
+ // Initialize the final entropy value for these cards
+ var entropyInt = BigInteger.ZERO;
+ // Track how many instances of each card have been used, and thus
+ // how many decks are in use.
+ var cardCounts = {};
+ // Track the total bits of entropy that remain, which diminishes as
+ // each card is drawn.
+ var totalBitsLeft = numberOfBits;
+ // Work out entropy contribution of each card drawn
+ for (var i=0; i<base.parts.length; i++) {
+ // Get the card that was drawn
+ var cardLower = base.parts[i];
+ var card = cardLower.toUpperCase();
+ // Initialize the deck for this card if needed, to track how
+ // much entropy it adds.
+ if (!(card in cardCounts)) {
+ cardCounts[card] = 0;
+ }
+ // Get the deck this card is from
+ var deckIndex = cardCounts[card];
+ while (deckIndex > sortedDecks.length-1) {
+ sortedDecks.push(getSortedDeck());
+ }
+ // See how many bits this card contributes (depends on how many
+ // are left in the deck it's from)
+ var deckForCard = sortedDecks[deckIndex];
+ var cardsLeftInDeck = deckForCard.length;
+ var additionalBits = Math.log2(cardsLeftInDeck);
+ // Work out the min and max value for this card
+ var nextTotalBitsLeft = totalBitsLeft - additionalBits;
+ var minPossibleNewEntropy = TWO.pow(nextTotalBitsLeft).subtract(1);
+ var maxPossibleNewEntropy = TWO.pow(totalBitsLeft).subtract(1);
+ var diff = maxPossibleNewEntropy.subtract(minPossibleNewEntropy);
+ // BigInteger aggresively floors numbers which greatly affects
+ // the small numbers. In that case, use native Math library
+ var useBigInt = totalBitsLeft >= 32;
+ if (!useBigInt) {
+ minPossibleNewEntropy = Math.round(Math.pow(2, nextTotalBitsLeft)-1);
+ maxPossibleNewEntropy = Math.round(Math.pow(2, totalBitsLeft)-1);
+ diff = maxPossibleNewEntropy - minPossibleNewEntropy;
+ }
+ // Scale the value between possible min and max depending on
+ // this card value
+ var thisCardIndex = deckForCard.indexOf(card);
+ var toAdd = BigInteger.ZERO;
+ if (cardsLeftInDeck > 1) {
+ if (useBigInt) {
+ toAdd = diff.multiply(thisCardIndex)
+ .divide(deckForCard.length - 1)
+ .add(minPossibleNewEntropy);
+ }
+ else {
+ var ratio = thisCardIndex / (deckForCard.length -1);
+ var f = diff * ratio;
+ toAdd = new BigInteger(f).add(minPossibleNewEntropy);
+ }
+ }
+ // Add this card entropy to existing entropy
+ entropyInt = entropyInt.add(toAdd);
+ // Remove this card from the deck it comes from
+ deckForCard.splice(thisCardIndex,1);
+ // Ensure the next insance of this card uses the next deck
+ cardCounts[card] = cardCounts[card] + 1;
+ // Next card drawn has less total remaining bits to work with
+ totalBitsLeft = nextTotalBitsLeft;
+ }
+ // Convert to binary
+ var entropyBin = entropyInt.toString(2);
+ var numberOfBitsInt = Math.floor(numberOfBits);
+ while (entropyBin.length < numberOfBitsInt) {
+ entropyBin = "0" + entropyBin;
+ }
+ }
// Supply a 'filtered' entropy string for display purposes
var entropyClean = base.parts.join("");
var entropyHtml = base.parts.join("");
entropyHtml = entropyHtml.replace(/H/g, "<span class='card-suit heart'>\u2665</span>");
entropyHtml = entropyHtml.replace(/S/g, "<span class='card-suit spade'>\u2660</span>");
}
+ // Return the result
var e = {
binaryStr: entropyBin,
cleanStr: entropyClean,
return e;
}
+ function getSortedDeck() {
+ var s = [];
+ var suits = "CDHS";
+ var values = "A23456789TJQK";
+ for (var i=0; i<suits.length; i++) {
+ for (var j=0; j<values.length; j++) {
+ s.push(values[j]+suits[i]);
+ }
+ }
+ return s;
+ }
+
function getBase(str) {
// Need to get the lowest base for the supplied entropy.
// This prevents interpreting, say, dice rolls as hexadecimal.
return BigInteger.log(x) / BigInteger.log(2);
};
+ // Depends on BigInteger
+ function factorial(n) {
+ if (n == 0) {
+ return 1;
+ }
+ f = BigInteger.ONE;
+ for (var i=1; i<=n; i++) {
+ f = f.multiply(new BigInteger(i));
+ }
+ return f;
+ }
+
})();
</script>
<script>(function() {
}
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";
}
// If time to crack is less than one day, and password is considered
console.log("Error detecting entropy strength with zxcvbn:");
console.log(e);
}
- var bitsStr = getNumberOfEntropyBits(entropy);
- var wordCount = Math.floor(entropy.binaryStr.length / 32) * 3;
var entropyTypeStr = getEntropyTypeStr(entropy);
+ var wordCount = Math.floor(numberOfBits / 32) * 3;
+ var bitsPerEvent = Math.log2(entropy.base.asInt).toFixed(2);
+ if (entropy.base.asInt == 52) {
+ bitsPerEvent = bitsPerEvent + " (or less)";
+ }
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.entropyBits.text(numberOfBits);
DOM.entropyWordCount.text(wordCount);
DOM.entropyBinary.text(entropy.binaryStr);
- DOM.entropyBitsPerEvent.text(Math.log2(entropy.base.asInt).toFixed(2));
- }
-
- function getNumberOfEntropyBits(entropy) {
- var bitsStr = entropy.binaryStr.length.toString();
- // If using cards, assume they are not reused, thus additional entropy
- // decreases as more cards are used. This means entropy is measured
- // using n!, not base^n.
- // eg the second last card can be only one of two, not one of fifty two
- // so the added entropy for that card is only one bit at most
- if (entropy.base.asInt == 52) {
- var totalDecks = Math.ceil(entropy.base.parts.length / 52);
- var totalCards = totalDecks * 52;
- var totalCombos = factorial(52).pow(totalDecks);
- var totalRemainingCards = totalCards - entropy.base.parts.length;
- var remainingDecks = Math.floor(totalRemainingCards / 52);
- var remainingCards = totalRemainingCards % 52;
- var remainingCombos = factorial(52).pow(remainingDecks) * factorial(remainingCards);
- var currentCombos = totalCombos.divide(remainingCombos);
- bitsStr = currentCombos.toString(2).length.toString();
- }
- return bitsStr
+ DOM.entropyBitsPerEvent.text(bitsPerEvent);
}
function getEntropyTypeStr(entropy) {
var dupeTracker = {};
for (var i=0; i<entropy.base.parts.length; i++) {
var card = entropy.base.parts[i];
- if (card in dupeTracker) {
+ var cardUpper = card.toUpperCase();
+ if (cardUpper in dupeTracker) {
dupes.push(card);
}
- dupeTracker[card] = true;
+ dupeTracker[cardUpper] = true;
}
if (dupes.length > 0) {
var dupeWord = "duplicates";
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;
}
- // Depends on BigInteger
- function factorial(n) {
- if (n == 0) {
- return 1;
- }
- f = BigInteger.ONE;
- for (var i=1; i<=n; i++) {
- f = f.multiply(new BigInteger(i));
- }
- return f;
- }
-
var networks = [
{
name: "Bitcoin",
projects / perso / Immae / Projets / Cryptomonnaies / BIP39.git / blobdiff