X-Git-Url: https://git.immae.eu/?a=blobdiff_plain;f=tests.js;h=10d13a324f5dfb6d0aab2aa3068be44f3affc361;hb=32fab2c39507357909438c2be8cd100c6539038f;hp=ec368cbf4ec018dbbe4502154a49d13c1b48bc76;hpb=c6624d51f4e5607202e48903352574c47571baab;p=perso%2FImmae%2FProjets%2FCryptomonnaies%2FBIP39.git diff --git a/tests.js b/tests.js index ec368cb..10d13a3 100644 --- a/tests.js +++ b/tests.js @@ -4,7 +4,12 @@ var page = require('webpage').create(); var url = 'src/index.html'; -var testMaxTime = 5000; +var testMaxTime = 10000; + +page.viewportSize = { + width: 1024, + height: 720 +}; page.onResourceError = function(e) { console.log("Error loading " + e.url); @@ -75,6 +80,36 @@ function waitForFeedback(fn, maxTime) { wait(); } +function waitForEntropyFeedback(fn, maxTime) { + if (!maxTime) { + maxTime = testMaxTime; + } + var origFeedback = page.evaluate(function() { + return $(".entropy-container").text(); + }); + var start = new Date().getTime(); + var wait = function keepWaiting() { + var now = new Date().getTime(); + var hasTimedOut = now - start > maxTime; + if (hasTimedOut) { + console.log("Test timed out"); + fn(); + return; + } + var feedback = page.evaluate(function() { + return $(".entropy-container").text(); + }); + var hasFinished = feedback != origFeedback; + if (hasFinished) { + fn(); + } + else { + setTimeout(keepWaiting, 100); + } + } + wait(); +} + function next() { if (tests.length > 0) { var testsStr = tests.length == 1 ? "test" : "tests"; @@ -1963,85 +1998,235 @@ page.open(url, function(status) { // Entropy unit tests function() { page.open(url, function(status) { - var error = page.evaluate(function() { + var response = page.evaluate(function() { var e; // binary entropy is detected - e = Entropy.fromString("01010101"); - if (e.base.str != "binary") { - return "Binary entropy not detected correctly"; + try { + e = Entropy.fromString("01010101"); + if (e.base.str != "binary") { + return "Binary entropy not detected correctly"; + } + } + catch (e) { + return e.message; } // base6 entropy is detected - e = Entropy.fromString("012345012345"); - if (e.base.str != "base 6") { - return "base6 entropy not detected correctly"; + try { + e = Entropy.fromString("012345012345"); + if (e.base.str != "base 6") { + return "base6 entropy not detected correctly"; + } + } + catch (e) { + return e.message; } // dice entropy is detected - e = Entropy.fromString("123456123456"); - if (e.base.str != "base 6 (dice)") { - return "dice entropy not detected correctly"; + try { + e = Entropy.fromString("123456123456"); + if (e.base.str != "base 6 (dice)") { + return "dice entropy not detected correctly"; + } + } + catch (e) { + return e.message; } // base10 entropy is detected - e = Entropy.fromString("0123456789"); - if (e.base.str != "base 10") { - return "base10 entropy not detected correctly"; + try { + e = Entropy.fromString("0123456789"); + if (e.base.str != "base 10") { + return "base10 entropy not detected correctly"; + } + } + catch (e) { + return e.message; } // hex entropy is detected - e = Entropy.fromString("0123456789ABCDEF"); - if (e.base.str != "hexadecimal") { - return "hexadecimal entropy not detected correctly"; + try { + e = Entropy.fromString("0123456789ABCDEF"); + if (e.base.str != "hexadecimal") { + return "hexadecimal entropy not detected correctly"; + } + } + catch (e) { + return e.message; + } + // card entropy is detected + try { + e = Entropy.fromString("AC4DTHKS"); + if (e.base.str != "card") { + return "card entropy not detected correctly"; + } + } + catch (e) { + return e.message; } // entropy is case insensitive - e = Entropy.fromString("aBcDeF"); - if (e.cleanStr != "aBcDeF") { - return "Entropy should not be case sensitive"; + try { + e = Entropy.fromString("aBcDeF"); + if (e.cleanStr != "aBcDeF") { + return "Entropy should not be case sensitive"; + } + } + catch (e) { + return e.message; } // dice entropy is converted to base6 - e = Entropy.fromString("123456"); - if (e.cleanStr != "012345") { - return "Dice entropy is not automatically converted to base6"; + try { + e = Entropy.fromString("123456"); + if (e.cleanStr != "123450") { + return "Dice entropy is not automatically converted to base6"; + } + } + catch (e) { + return e.message; } // dice entropy is preferred to base6 if ambiguous - e = Entropy.fromString("12345"); - if (e.base.str != "base 6 (dice)") { - return "dice not used as default over base 6"; + try { + e = Entropy.fromString("12345"); + if (e.base.str != "base 6 (dice)") { + return "dice not used as default over base 6"; + } + } + catch (e) { + return e.message; } // unused characters are ignored - e = Entropy.fromString("fghijkl"); - if (e.cleanStr != "f") { - return "additional characters are not ignored"; + try { + e = Entropy.fromString("fghijkl"); + if (e.cleanStr != "f") { + return "additional characters are not ignored"; + } + } + catch (e) { + return e.message; } // the lowest base is used by default // 7 could be decimal or hexadecimal, but should be detected as decimal - e = Entropy.fromString("7"); - if (e.base.str != "base 10") { - return "lowest base is not used"; + try { + e = Entropy.fromString("7"); + if (e.base.str != "base 10") { + return "lowest base is not used"; + } } - // Hexadecimal representation is returned - e = Entropy.fromString("1010"); - if (e.hexStr != "A") { - return "Hexadecimal representation not returned"; + catch (e) { + return e.message; } // Leading zeros are retained - e = Entropy.fromString("000A"); - if (e.cleanStr != "000A") { - return "Leading zeros are not retained"; + try { + e = Entropy.fromString("000A"); + if (e.cleanStr != "000A") { + return "Leading zeros are not retained"; + } + } + catch (e) { + return e.message; } // Leading zeros are correctly preserved for hex in binary string - e = Entropy.fromString("2A"); - if (e.binaryStr != "00101010") { - return "Hex leading zeros are not correct in binary"; + try { + e = Entropy.fromString("2A"); + if (e.binaryStr != "00101010") { + return "Hex leading zeros are not correct in binary"; + } + } + catch (e) { + return e.message; + } + // Leading zeros for base 6 as binary string + // 20 = 2 events at 2.58 bits per event = 5 bits + // 20 in base 6 = 12 in base 10 = 1100 in base 2 + // so it needs 1 bit of padding to be the right bit length + try { + e = Entropy.fromString("20"); + if (e.binaryStr != "01100") { + return "Base 6 as binary has leading zeros"; + } + } + catch (e) { + return e.message; + } + // Leading zeros for base 10 as binary string + try { + e = Entropy.fromString("17"); + if (e.binaryStr != "010001") { + return "Base 10 as binary has leading zeros"; + } + } + catch (e) { + return e.message; + } + // Leading zeros for card entropy as binary string. + // Card entropy is hashed so 2c does not produce leading zeros. + try { + e = Entropy.fromString("4c"); + if (e.binaryStr != "0001") { + return "Card entropy as binary has leading zeros"; + } + } + catch (e) { + return e.message; } // Keyboard mashing results in weak entropy // Despite being a long string, it's less than 30 bits of entropy - e = Entropy.fromString("aj;se ifj; ask,dfv js;ifj"); - if (e.binaryStr.length >= 30) { - return "Keyboard mashing should produce weak entropy"; + try { + e = Entropy.fromString("aj;se ifj; ask,dfv js;ifj"); + if (e.binaryStr.length >= 30) { + return "Keyboard mashing should produce weak entropy"; + } } - return false; + catch (e) { + return e.message; + } + // Card entropy is used if every pair could be a card + try { + e = Entropy.fromString("4c3c2c"); + if (e.base.str != "card") { + return "Card entropy not used if all pairs are cards"; + } + } + catch (e) { + return e.message; + } + // Card entropy uses base 52 + // [ cards, binary ] + try { + var cards = [ + [ "ac", "0100" ], + [ "acqs", "10111101" ], + [ "acks", "11110000" ], + [ "2cac", "11000010" ], + [ "2c", "1000" ], + [ "3d", "1111" ], + [ "4h", "0011" ], + [ "5s", "1001" ], + [ "6c", "1011" ], + [ "7d", "1101" ], + [ "8h", "1011" ], + [ "9s", "1010" ], + [ "tc", "1101" ], + [ "jd", "1101" ], + [ "qh", "1100" ], + [ "ks", "1111" ], + [ "ks2c", "10000001" ], + [ "KS2C", "10000001" ], + ]; + for (var i=0; i 0) { - console.log("Mnemonic length for " + test.nextStrength + " strength is not " + test.words); + console.log("Mnemonic length for " + test.strength + " strength is not " + test.words); + console.log("Entropy: " + test.entropy); console.log("Mnemonic: " + mnemonic); fail(); } } - else { + else if ("words" in test) { if (mnemonic.split(" ").length != test.words) { - console.log("Mnemonic length for " + test.nextStrength + " strength is not " + test.words); + console.log("Mnemonic length for " + test.strength + " strength is not " + test.words); + console.log("Entropy: " + test.entropy); console.log("Mnemonic: " + mnemonic); fail(); } } - // check the strength of the next mnemonic is shown - var entropyText = page.evaluate(function() { + // check feedback + var feedback = page.evaluate(function() { return $(".entropy-container").text(); }); - if (entropyText.indexOf("required to generate " + test.nextStrength + " mnemonic") == -1) { - console.log("Strength indicator for " + test.nextStrength + " mnemonic is incorrect"); + var feedbackError = getFeedbackError(test, feedback); + if (feedbackError) { + console.log("Entropy feedback for " + test.entropy + " returned error"); + console.log(feedbackError); fail(); } + // Run next test var isLastTest = i == tests.length - 1; if (isLastTest) { next(); @@ -2480,15 +2854,16 @@ page.open(url, function(status) { }); }, -// Entropy is truncated from the right +// Entropy is truncated from the left function() { page.open(url, function(status) { - var expected = "abandon abandon ability"; + var expected = "avocado zoo zone"; // use entropy page.evaluate(function() { $(".use-entropy").prop("checked", true).trigger("change"); + $(".mnemonic-length").val("raw"); var entropy = "00000000 00000000 00000000 00000000"; - entropy += "11111111 11111111 11111111 1111"; // Missing last byte, only first 8 bytes are used + entropy += "11111111 11111111 11111111 1111"; // Missing last byte $(".entropy").val(entropy).trigger("input"); }); // check the entropy is truncated from the right @@ -2513,6 +2888,7 @@ page.open(url, function(status) { // use entropy page.evaluate(function() { $(".use-entropy").prop("checked", true).trigger("change"); + $(".mnemonic-length").val("raw"); var entropy = ""; // Generate a very long entropy string for (var i=0; i<33; i++) { @@ -2539,16 +2915,15 @@ page.open(url, function(status) { // https://bip32jp.github.io/english/index.html // NOTES: // Is incompatible with: -// base 6 with leading zeros -// base 6 wth 12 words / 53 chars // base 20 function() { page.open(url, function(status) { - var expected = "defy trip fatal jaguar mean rack rifle survey satisfy drift twist champion steel wife state furnace night consider glove olympic oblige donor novel left"; + var expected = "train then jungle barely whip fiber purpose puppy eagle cloud clump hospital robot brave balcony utility detect estate old green desk skill multiply virus"; // use entropy page.evaluate(function() { $(".use-entropy").prop("checked", true).trigger("change"); - var entropy = "123450123450123450123450123450123450123450123450123450123450123450123450123450123450123450123450123"; + $(".mnemonic-length").val("raw"); + var entropy = "543210543210543210543210543210543210543210543210543210543210543210543210543210543210543210543210543"; $(".entropy").val(entropy).trigger("input"); }); // check the mnemonic matches the expected value from bip32jp @@ -2567,6 +2942,151 @@ page.open(url, function(status) { }); }, +// Blank entropy does not generate mnemonic or addresses +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + $(".entropy").val("").trigger("input"); + }); + waitForFeedback(function() { + // check there is no mnemonic + var phrase = page.evaluate(function() { + return $(".phrase").val(); + }); + if (phrase != "") { + console.log("Blank entropy does not result in blank mnemonic"); + console.log("Got: " + phrase); + fail(); + } + // check there are no addresses displayed + var addresses = page.evaluate(function() { + return $(".address").length; + }); + if (addresses != 0) { + console.log("Blank entropy does not result in zero addresses"); + fail(); + } + // Check the feedback says 'blank entropy' + var feedback = page.evaluate(function() { + return $(".feedback").text(); + }); + if (feedback != "Blank entropy") { + console.log("Blank entropy does not show feedback message"); + fail(); + } + next(); + }); +}); +}, + +// Mnemonic length can be selected even for weak entropy +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + $(".entropy").val("012345"); + $(".mnemonic-length").val("18").trigger("change"); + }); + // check the mnemonic is the correct length + waitForGenerate(function() { + var phrase = page.evaluate(function() { + return $(".phrase").val(); + }); + var numberOfWords = phrase.split(/\s/g).length; + if (numberOfWords != 18) { + console.log("Weak entropy cannot be overridden to give 18 word mnemonic"); + console.log(phrase); + fail(); + } + next(); + }); +}); +}, + +// Github issue 33 +// https://github.com/iancoleman/bip39/issues/33 +// Final cards should contribute entropy +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".use-entropy").prop("checked", true).trigger("change"); + $(".mnemonic-length").val("raw"); + $(".entropy").val("7S 9H 9S QH 8C KS AS 7D 7C QD 4S 4D TC 2D 5S JS 3D 8S 8H 4C 3C AC 3S QC 9C JC 7H AD TD JD 6D KH 5C QS 2S 6S 6H JH KD 9D-6C TS TH 4H KC 5H 2H AH 2C 8D 3H 5D").trigger("input"); + }); + // get the mnemonic + waitForGenerate(function() { + var originalPhrase = page.evaluate(function() { + return $(".phrase").val(); + }); + // Set the last 12 cards to be AS + page.evaluate(function() { + $(".addresses").empty(); + $(".entropy").val("7S 9H 9S QH 8C KS AS 7D 7C QD 4S 4D TC 2D 5S JS 3D 8S 8H 4C 3C AC 3S QC 9C JC 7H AD TD JD 6D KH 5C QS 2S 6S 6H JH KD 9D-AS AS AS AS AS AS AS AS AS AS AS AS").trigger("input"); + }); + // get the new mnemonic + waitForGenerate(function() { + var newPhrase = page.evaluate(function() { + return $(".phrase").val(); + }); + // check the phrase has changed + if (newPhrase == originalPhrase) { + console.log("Changing last 12 cards does not change mnemonic"); + console.log("Original:"); + console.log(originalPhrase); + console.log("New:"); + console.log(newPhrase); + fail(); + } + next(); + }); + }); +}); +}, + +// Github issue 35 +// https://github.com/iancoleman/bip39/issues/35 +// QR Code support +function() { +page.open(url, function(status) { + // use entropy + page.evaluate(function() { + $(".generate").click(); + }); + waitForGenerate(function() { + var p = page.evaluate(function() { + // get position of mnemonic element + return $(".phrase").offset(); + }); + p.top = Math.ceil(p.top); + p.left = Math.ceil(p.left); + // check the qr code shows + page.sendEvent("mousemove", p.left+4, p.top+4); + var qrShowing = page.evaluate(function() { + return $(".qr-container").find("canvas").length > 0; + }); + if (!qrShowing) { + console.log("QR Code does not show"); + fail(); + } + // check the qr code hides + page.sendEvent("mousemove", p.left-4, p.top-4); + var qrHidden = page.evaluate(function() { + return $(".qr-container").find("canvas").length == 0; + }); + if (!qrHidden) { + console.log("QR Code does not hide"); + fail(); + } + next(); + }); +}); +}, + + // If you wish to add more tests, do so here... // Here is a blank test template