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 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
def check_seed(self, seed, custom_entropy):
assert is_new_seed(seed)
i = self.mnemonic_decode(seed)
return i % custom_entropy == 0
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
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({})
