def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX, custom_entropy=1): n = int(math.ceil(math.log(custom_entropy, 2))) # bits of entropy used by the prefix k = len(prefix) * 4 # we add at least 16 bits n_added = max(16, k + num_bits - n) print_error("make_seed", prefix, "adding %d bits" % n_added) my_entropy = ecdsa.util.randrange(pow(2, n_added)) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) try: assert i == self.mnemonic_decode(seed) except AssertionError: # If assertion fails, generate new seed continue if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words' % len(seed.split())) return seed
def from_seed(seed, password): if is_old_seed(seed): keystore = Old_KeyStore() keystore.add_seed(seed, password) elif is_new_seed(seed): keystore = BIP32_KeyStore() keystore.add_seed_and_xprv(seed, password) return keystore
def from_seed(seed, password): if is_old_seed(seed): keystore = Old_KeyStore({}) keystore.add_seed(seed, password) elif is_new_seed(seed): keystore = BIP32_KeyStore({}) keystore.add_seed(seed, password) bip32_seed = Mnemonic.mnemonic_to_seed(seed, '') keystore.add_xprv_from_seed(bip32_seed, "m/", password) return keystore
def from_seed(seed, passphrase): if is_old_seed(seed): keystore = Old_KeyStore({}) keystore.add_seed(seed) elif is_new_seed(seed): keystore = BIP32_KeyStore({}) keystore.add_seed(seed) keystore.passphrase = passphrase bip32_seed = Mnemonic.mnemonic_to_seed(seed, passphrase) keystore.add_xprv_from_seed(bip32_seed, "m/") return keystore
def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX): # increase num_bits in order to obtain a uniform distibution for the last word bpw = math.log(len(self.wordlist), 2) n = int(math.ceil(num_bits / bpw)) * bpw print_error("make_seed", prefix, "adding %d bits" % n) my_entropy = ecdsa.util.randrange(pow(2, n)) nonce = 0 while True: nonce += 1 i = my_entropy + nonce seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words' % len(seed.split())) return seed
def make_seed(self, num_bits=128, custom_entropy=1): n = int(math.ceil(math.log(custom_entropy, 2))) # we add at least 16 bits n_added = max(16, 8 + num_bits - n) print_error("make_seed: adding %d bits" % n_added) my_entropy = ecdsa.util.randrange(pow(2, n_added)) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue # this removes 8 bits of entropy if is_new_seed(seed): break print_error('%d words' % len(seed.split())) return seed
def make_seed(self, num_bits=128, custom_entropy=1): n = int(math.ceil(math.log(custom_entropy,2))) # we add at least 16 bits n_added = max(16, 8 + num_bits - n) print_error("make_seed: adding %d bits"%n_added) my_entropy = ecdsa.util.randrange( pow(2, n_added) ) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue # this removes 8 bits of entropy if is_new_seed(seed): break print_error('%d words'%len(seed.split())) return seed
def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX, custom_entropy=1): n = int(math.ceil(math.log(custom_entropy,2))) # bits of entropy used by the prefix k = len(prefix)*4 # we add at least 16 bits n_added = max(16, k + num_bits - n) print_error("make_seed", prefix, "adding %d bits"%n_added) my_entropy = ecdsa.util.randrange( pow(2, n_added) ) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words'%len(seed.split())) return seed
def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX, custom_entropy=1): # increase num_bits in order to obtain a uniform distibution for the last word bpw = math.log(len(self.wordlist), 2) num_bits = int(math.ceil(num_bits/bpw)) * bpw # handle custom entropy; make sure we add at least 16 bits n_custom = int(math.ceil(math.log(custom_entropy, 2))) n = max(16, num_bits - n_custom) print_error("make_seed", prefix, "adding %d bits"%n) my_entropy = ecdsa.util.randrange(pow(2, n)) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words'%len(seed.split())) return seed
def make_seed(self, num_bits=128, prefix=version.SEED_PREFIX): # increase num_bits in order to obtain a uniform distibution for the last word bpw = math.log(len(self.wordlist), 2) n = int(math.ceil(num_bits / bpw)) * bpw print_error("make_seed", prefix, "adding %d bits" % n) my_entropy = ecdsa.util.randrange(pow(2, n)) nonce = 0 while True: nonce += 1 i = my_entropy + nonce seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print nonce print_error('%d words' % len(seed.split())) return seed # def make_old_seed(self): # import old_mnemonic, ecdsa # entropy = ecdsa.util.randrange( pow(2,160) ) # nonce = 0 # while True: # ss = "%040x"%(entropy+nonce) # s = hashlib.sha256(ss.decode('hex')).digest().encode('hex') # # we keep only 13 words, that's approximately 139 bits of entropy # words = old_mnemonic.mn_encode(s)[0:12] # seed = ' '.join(words) # if is_seed(seed): # break # this will remove 8 bits of entropy # nonce += 1 # # return seed # # from version import SEED_PREFIX # hmac_sha_512 = lambda x,y: hmac.new(x, y, hashlib.sha512).digest() # is_seed = lambda x: hmac_sha_512("Seed version", x).encode('hex')[0:2].startswith(SEED_PREFIX)
def make_seed(self, seed_type='standard', num_bits=132, custom_entropy=1): import version prefix = version.seed_prefix(seed_type) # increase num_bits in order to obtain a uniform distibution for the last word bpw = math.log(len(self.wordlist), 2) num_bits = int(math.ceil(num_bits / bpw)) * bpw # handle custom entropy; make sure we add at least 16 bits n_custom = int(math.ceil(math.log(custom_entropy, 2))) n = max(16, num_bits - n_custom) print_error("make_seed", prefix, "adding %d bits" % n) my_entropy = ecdsa.util.randrange(pow(2, n)) nonce = 0 while True: nonce += 1 i = custom_entropy * (my_entropy + nonce) seed = self.mnemonic_encode(i) assert i == self.mnemonic_decode(seed) if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words' % len(seed.split())) return seed
def make_seed(self, seed_type='standard', num_bits=132): prefix = version.seed_prefix(seed_type) # increase num_bits in order to obtain a uniform distribution for the last word bpw = math.log(len(self.wordlist), 2) # rounding n = int(math.ceil(num_bits / bpw) * bpw) print_error("make_seed. prefix: '%s'" % prefix, "entropy: %d bits" % n) entropy = 1 while entropy < pow(2, n - bpw): # try again if seed would not contain enough words entropy = ecdsa.util.randrange(pow(2, n)) nonce = 0 while True: nonce += 1 i = entropy + nonce seed = self.mnemonic_encode(i) if i != self.mnemonic_decode(seed): raise Exception('Cannot extract same entropy from mnemonic!') if is_old_seed(seed): continue if is_new_seed(seed, prefix): break print_error('%d words' % len(seed.split())) return seed
words_to_hash = words else: words_to_hash = words + " " + str(nonce) # # Generate the hash and take the first half of the hash since # mnemonic_encode expects 16 bytes seed # hash_obj = hashlib.sha256(words_to_hash) seed1 = hash_obj.hexdigest() seed2 = int(seed1[:34], 16) # # Get back the mnemonic based on the words of dictionary # Check if fits criteria, if so stop, otherwise keep incrementing # the nounce mwords = Mnemonic().mnemonic_encode(seed2) if is_new_seed(mwords, version.SEED_PREFIX): break nonce += 1 seed = seed2 print "===========================" print "========= RESULT ==========" print "===========================" print "mnemonic phrase to use to generate back your wallet:" print str(mwords) print "===========================" print "===========================" print "seed used " + hex(seed) print "Final phrase used was: " print words_to_hash
def check_seed(self, seed, custom_entropy): assert is_new_seed(seed) i = self.mnemonic_decode(seed) return i % custom_entropy == 0
return False try: deserialize_xkey(text) return True except: return False def is_address_list(text): parts = text.split() return bool(parts) and all(bitcoin.is_address(x) for x in parts) def is_private_key_list(text): parts = text.split() return bool(parts) and all(bitcoin.is_private_key(x) for x in parts) is_seed = lambda x: is_old_seed(x) or is_new_seed(x) is_mpk = lambda x: is_old_mpk(x) or is_xpub(x) is_private = lambda x: is_seed(x) or is_xprv(x) or is_private_key_list(x) is_any_key = lambda x: is_old_mpk(x) or is_xprv(x) or is_xpub(x) or is_address_list(x) or is_private_key_list(x) is_private_key = lambda x: is_xprv(x) or is_private_key_list(x) is_bip32_key = lambda x: is_xprv(x) or is_xpub(x) def bip44_derivation(account_id): return "m/44'/0'/%d'"% int(account_id) def from_seed(seed, passphrase): if is_old_seed(seed): keystore = Old_KeyStore({}) keystore.add_seed(seed) elif is_new_seed(seed): keystore = BIP32_KeyStore({})