def get_last_word(first_words):
_, is_wordlist_valid = bip39_is_checksum_valid(first_words)
if is_wordlist_valid is False:
raise Exception("Invalid BIP39 Word in first_words: %s" % first_words)
# Find last word
for word in Wordlist.from_file("english.txt"):
challenge = first_words + " " + word
is_checksum_valid, _ = bip39_is_checksum_valid(challenge)
if is_checksum_valid:
return word
raise Exception("Can't find valid checksum word")
def calculate_seed_and_xpubs(first_words):
first_words = first_words.strip()
last_word = get_last_word(first_words=first_words)
whole_seed = first_words + " " + last_word
is_checksum_valid, _ = bip39_is_checksum_valid(whole_seed)
assert is_checksum_valid is True
if constants.net == constants.BitcoinMainnet:
derivation_path = "m/48'/0'/0'/2'"
elif constants.net == constants.BitcoinTestnet:
derivation_path = "m/48'/1'/0'/2'"
else:
raise Exception("Invalid Network: %s" % constants.net)
ks = from_bip39_seed(seed=whole_seed, passphrase="", derivation=derivation_path)
return (
{
"last_word": last_word,
"whole_seed": whole_seed,
"whole_seed_word_count": len(whole_seed.split()),
},
{
"xfp": ks.get_root_fingerprint().upper(), # uppercase to match others, unsure if that matters
"p2wsh": ks.get_master_public_key(),
"p2wsh_deriv": derivation_path,
},
)
def main():
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--check', action='store_true', default=False)
args = arg_parser.parse_args()
lines = [x.strip() for x in sys.stdin.readlines()]
words = ""
passw = ""
if len(lines) == 2:
passw = lines[1]
if not (len(lines) in [1, 2]):
print("wrong input", file=sys.stderr)
sys.exit(1)
words = lines[0]
if (args.check):
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(words)
if not wordlist_ok:
print("Unkown words!", file=sys.stderr)
sys.exit(1)
if not checksum_ok:
print("Checksum NOT OK!", file=sys.stderr)
sys.exit(1)
print(util.bh2u(keystore.bip39_to_seed(words, passw)))
def main():
f = open('seedwords.txt')
lines = f.read().split('\n')
threads = []
for line in lines:
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(line)
print("[CHECK] " + line)
if not wordlist_ok:
print(" Unknown words!", file=sys.stderr)
continue
if not checksum_ok:
print(" Checksum NOT OK!", file=sys.stderr)
continue
print(" Check passed. Queued.")
t = threading.Thread(target=checkPassphrase, args=(line, ))
threads.append(t)
t.start()
if len(threads) == MAX_THREADS:
for t in threads:
t.join()
threads.clear()
def update_next_button(self):
from electrum.keystore import bip39_is_checksum_valid
text = self.get_text()
if self.is_bip39:
is_seed, is_wordlist = bip39_is_checksum_valid(text)
else:
is_seed = bool(self._test(text))
self.ids.next.disabled = not is_seed
def verify_seed(self,
seed,
bip39=False,
slip39=False,
wallet_type='standard',
language='en'):
self._logger.debug('bip39 ' + str(bip39))
self._logger.debug('slip39 ' + str(slip39))
seed_type = ''
seed_valid = False
validation_message = ''
if not (bip39 or slip39):
seed_type = mnemonic.seed_type(seed)
if seed_type != '':
seed_valid = True
elif bip39:
is_checksum, is_wordlist = bip39_is_checksum_valid(seed)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')
) if is_wordlist else 'unknown wordlist'
validation_message = 'BIP39 (%s)' % status
if is_checksum:
seed_type = 'bip39'
seed_valid = True
elif slip39: # TODO: incomplete impl, this code only validates a single share.
try:
share = decode_mnemonic(seed)
seed_type = 'slip39'
validation_message = 'SLIP39: share #%d in %dof%d scheme' % (
share.group_index, share.group_threshold,
share.group_count)
except Slip39Error as e:
validation_message = 'SLIP39: %s' % str(e)
seed_valid = False # for now
# cosigning seed
if wallet_type != 'standard' and seed_type not in [
'standard', 'segwit'
]:
seed_type = ''
seed_valid = False
self.seedType = seed_type
self.seedTypeChanged.emit()
if self.validationMessage != validation_message:
self.validationMessage = validation_message
self.validationMessageChanged.emit()
if self.seedValid != seed_valid:
self.seedValid = seed_valid
self.seedValidChanged.emit()
self._logger.debug('seed verified: ' + str(seed_valid))
def on_edit(self):
s = ' '.join(self.get_seed_words())
b = self.is_seed(s)
if self.seed_type == 'bip39':
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')
) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)' % status
elif self.seed_type == 'slip39':
self.slip39_mnemonics[self.slip39_mnemonic_index] = s
try:
slip39.decode_mnemonic(s)
except slip39.Slip39Error as e:
share_status = str(e)
current_mnemonic_invalid = True
else:
share_status = _('Valid.')
current_mnemonic_invalid = False
label = _('SLIP39 share') + ' #%d: %s' % (
self.slip39_mnemonic_index + 1, share_status)
# No need to process mnemonics if the current mnemonic remains invalid after editing.
if not (self.slip39_current_mnemonic_invalid
and current_mnemonic_invalid):
self.slip39_seed, seed_status = slip39.process_mnemonics(
self.slip39_mnemonics)
self.seed_status.setText(seed_status)
self.slip39_current_mnemonic_invalid = current_mnemonic_invalid
b = self.slip39_seed is not None
self.update_share_buttons()
else:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
if t and not b: # electrum seed, but does not conform to dialog rules
msg = ' '.join([
'<b>' + _('Warning') + ':</b> ',
_("Looks like you have entered a valid seed of type '{}' but this dialog does not support such seeds."
).format(t),
_("If unsure, try restoring as '{}'.").format(
_("Standard wallet")),
])
self.seed_warning.setText(msg)
else:
self.seed_warning.setText("")
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# disable suggestions if user already typed an unknown word
for word in self.get_seed_words()[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def on_edit(self, *, from_click=False):
s = ' '.join(self.get_seed_words())
b = self.is_seed(s)
from electrum.keystore import bip39_is_checksum_valid
from electrum.mnemonic import Wordlist, filenames
lang = ''
for type, file in filenames.items():
word_list = Wordlist.from_file(file)
is_checksum, is_wordlist = bip39_is_checksum_valid(s, wordlist=word_list)
if is_wordlist:
lang = type
break
if self.seed_type == 'bip39':
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39 - ' + lang + ' (%s)'%status
if lang and lang != self.lang:
if lang == 'en':
bip39_english_list = Mnemonic('en').wordlist
old_list = old_mnemonic.wordlist
only_old_list = set(old_list) - set(bip39_english_list)
self.wordlist = list(bip39_english_list) + list(only_old_list) # concat both lists
self.wordlist.sort()
self.completer.model().setStringList(self.wordlist)
self.lang = 'en'
else:
self.wordlist = list(Mnemonic(lang).wordlist)
self.wordlist.sort()
self.completer.model().setStringList(self.wordlist)
self.lang = lang
b = is_checksum
else:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
if is_checksum and is_wordlist and not from_click:
# This is a valid bip39 and this method was called from typing
# Emulate selecting the bip39 option
self.clayout.group.buttons()[1].click()
return
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# disable suggestions if user already typed an unknown word
for word in self.get_seed_words()[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def on_edit(self):
s = self.get_seed()
b = self.is_seed(s)
if not self.is_bip39:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
else:
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)'%status
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
def on_edit(self):
from electrum.bitcoin import seed_type
s = self.get_seed()
b = self.is_seed(s)
if not self.is_bip39:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
else:
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)'%status
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
def main():
SEED_COUNTER = 0
VALID_SEED_COUNT = 0
TOTAL_COUNTER = 0
SEED_START_TIME = time.time()
while True:
# GENERATE NEW SEED PHRASE
word = ""
WORD_COUNT = 0
SEED_TO_TEST = ''
for suit in my_shuffle(SEED_ARRAY):
if (WORD_COUNT <= 24):
word = word + " " + suit
WORD_COUNT += 1
if (WORD_COUNT == 24):
line = word
threads = []
SEED_COUNTER += 1
if (SEED_COUNTER >= 1000):
TOTAL_COUNTER += SEED_COUNTER
SEED_COUNTER = 0
TIME_SINCE = time.time() - SEED_START_TIME
print("[BRUTEFORCE] Checked " + str(TOTAL_COUNTER) +
" seeds and found " + str(VALID_SEED_COUNT) +
" valid seeds in " + str(TIME_SINCE) + " seconds.")
(checksum_ok,
wordlist_ok) = keystore.bip39_is_checksum_valid(line)
if not wordlist_ok:
print(" Unknown words!" + line, file=sys.stderr)
continue
if not checksum_ok:
#print(" Checksum NOT OK!" + line, file=sys.stderr)
continue
#print(" Check passed. Queued: " + line)
VALID_SEED_COUNT += 1
t = threading.Thread(target=checkPassphrase, args=(line, ))
threads.append(t)
t.start()
if len(threads) == MAX_THREADS:
for t in threads:
t.join()
threads.clear()
def main():
words = read_and_validate()
wordlist = mnemonic.Mnemonic().wordlist
print("Good last words:")
ok_words = []
for last in wordlist:
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(
" ".join(words + [last]))
assert wordlist_ok
if checksum_ok:
print(last)
ok_words.append(last)
prng = coinchooser.PRNG(os.urandom(100))
print("\nA random choice would be:")
print(prng.choice(ok_words))
def on_edit(self):
s = ' '.join(self.get_seed_words())
b = self.is_seed(s)
if self.seed_type == 'bip39':
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')
) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)' % status
elif self.seed_type == 'slip39':
self.slip39_mnemonics[self.slip39_mnemonic_index] = s
try:
slip39.decode_mnemonic(s)
except slip39.Slip39Error as e:
share_status = str(e)
current_mnemonic_invalid = True
else:
share_status = _('Valid.')
current_mnemonic_invalid = False
label = _('SLIP39 share') + ' #%d: %s' % (
self.slip39_mnemonic_index + 1, share_status)
# No need to process mnemonics if the current mnemonic remains invalid after editing.
if not (self.slip39_current_mnemonic_invalid
and current_mnemonic_invalid):
self.slip39_seed, seed_status = slip39.process_mnemonics(
self.slip39_mnemonics)
self.seed_status.setText(seed_status)
self.slip39_current_mnemonic_invalid = current_mnemonic_invalid
b = self.slip39_seed is not None
self.update_share_buttons()
else:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# disable suggestions if user already typed an unknown word
for word in self.get_seed_words()[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def on_edit(self):
s = self.get_seed()
b = self.is_seed(s)
if not self.is_bip39:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
else:
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)'%status
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# disable suggestions if user already typed an unknown word
for word in self.get_seed().split(" ")[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def on_edit(self):
s = self.get_seed()
b = self.is_seed(s)
if not self.is_bip39:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
else:
from electrum.keystore import bip39_is_checksum_valid
is_checksum, is_wordlist = bip39_is_checksum_valid(s)
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39' + ' (%s)'%status
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# to account for bip39 seeds
for word in self.get_seed().split(" ")[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def read_and_validate():
lines = [x.strip() for x in sys.stdin.readlines()]
if len(lines) != 1:
print("Give words in one line", file=sys.stderr)
sys.exit(1)
first_line = lines[0]
words = first_line.split()
if (len(words) + 1) not in ACCEPTED_LENGTHS:
print("{0} words given, but number should be one of {1}".format(
len(words), str([x - 1 for x in ACCEPTED_LENGTHS])),
file=sys.stderr)
sys.exit(1)
(first_checksum_ok,
first_wordlist_ok) = keystore.bip39_is_checksum_valid(" ".join(words))
if not first_wordlist_ok:
print("Unkown words!", file=sys.stderr)
sys.exit(1)
return words
def on_edit(self):
s = ' '.join(self.get_seed_words())
b = self.is_seed(s)
if self.seed_type == 'bip39':
from electrum.keystore import bip39_is_checksum_valid
from electrum.mnemonic import Wordlist, filenames
lang = ''
for type, file in filenames.items():
word_list = Wordlist.from_file(file)
is_checksum, is_wordlist = bip39_is_checksum_valid(s, wordlist=word_list)
if is_wordlist:
lang = type
break
status = ('checksum: ' + ('ok' if is_checksum else 'failed')) if is_wordlist else 'unknown wordlist'
label = 'BIP39 - ' + lang + ' (%s)'%status
if lang and lang != self.lang:
if lang == 'en':
bip39_english_list = Mnemonic('en').wordlist
old_list = old_mnemonic.wordlist
only_old_list = set(old_list) - set(bip39_english_list)
self.wordlist = list(bip39_english_list) + list(only_old_list) # concat both lists
self.wordlist.sort()
self.completer.model().setStringList(self.wordlist)
self.lang = 'en'
else:
self.wordlist = list(Mnemonic(lang).wordlist)
self.wordlist.sort()
self.completer.model().setStringList(self.wordlist)
self.lang = lang
elif self.seed_type == 'slip39':
self.slip39_mnemonics[self.slip39_mnemonic_index] = s
try:
slip39.decode_mnemonic(s)
except slip39.Slip39Error as e:
share_status = str(e)
current_mnemonic_invalid = True
else:
share_status = _('Valid.')
current_mnemonic_invalid = False
label = _('SLIP39 share') + ' #%d: %s' % (self.slip39_mnemonic_index + 1, share_status)
# No need to process mnemonics if the current mnemonic remains invalid after editing.
if not (self.slip39_current_mnemonic_invalid and current_mnemonic_invalid):
self.slip39_seed, seed_status = slip39.process_mnemonics(self.slip39_mnemonics)
self.seed_status.setText(seed_status)
self.slip39_current_mnemonic_invalid = current_mnemonic_invalid
b = self.slip39_seed is not None
self.update_share_buttons()
else:
t = seed_type(s)
label = _('Seed Type') + ': ' + t if t else ''
self.seed_type_label.setText(label)
self.parent.next_button.setEnabled(b)
# disable suggestions if user already typed an unknown word
for word in self.get_seed_words()[:-1]:
if word not in self.wordlist:
self.seed_e.disable_suggestions()
return
self.seed_e.enable_suggestions()
def main():
SEED_COUNTER=0
VALID_SEED_COUNT=0
TOTAL_COUNTER=0
SEED_START_TIME=time.time()
while True:
# GENERATE NEW SEED PHRASE
word=""
PAIRED_LIST=""
WORD_COUNT=0
SEED_TO_TEST=''
for suit in my_shuffle(SEED_ARRAY):
if (WORD_COUNT <= 18):
word=word+" "+suit
WORD_COUNT+= 1
if (WORD_COUNT == 18):
#pair up the shuffled words
CHOSEN_WORDS=word.split()
PAIRED_LIST=[]
PAIRED_LIST.append('code easily')
PAIRED_LIST.append('attack early')
PAIRED_LIST.append('almost open')
PAIRED_LIST.append(CHOSEN_WORDS[0]+' '+CHOSEN_WORDS[1])
PAIRED_LIST.append(CHOSEN_WORDS[2]+' '+CHOSEN_WORDS[3])
PAIRED_LIST.append(CHOSEN_WORDS[4]+' '+CHOSEN_WORDS[5])
PAIRED_LIST.append(CHOSEN_WORDS[6]+' '+CHOSEN_WORDS[7])
PAIRED_LIST.append(CHOSEN_WORDS[8]+' '+CHOSEN_WORDS[9])
PAIRED_LIST.append(CHOSEN_WORDS[10]+' '+CHOSEN_WORDS[11])
PAIRED_LIST.append(CHOSEN_WORDS[12]+' '+CHOSEN_WORDS[13])
PAIRED_LIST.append(CHOSEN_WORDS[14]+' '+CHOSEN_WORDS[15])
PAIRED_LIST.append(CHOSEN_WORDS[16]+' '+CHOSEN_WORDS[17])
# Now shuffle the pairs and generate seed phrase
PAIRED_WORDS=""
PAIRED_WORD_COUNT=0
for PAIR in my_shuffle(PAIRED_LIST):
if (PAIRED_WORD_COUNT <= 12):
PAIRED_WORDS=PAIRED_WORDS+" "+PAIR
PAIRED_WORD_COUNT+= 1
if (PAIRED_WORD_COUNT == 12):
line = PAIRED_WORDS
threads = []
SEED_COUNTER+=1
if (SEED_COUNTER >= 1000):
TOTAL_COUNTER+=SEED_COUNTER
SEED_COUNTER=0
TIME_SINCE=time.time()-SEED_START_TIME
print("[BRUTEFORCE] Checked "+str(TOTAL_COUNTER)+" seeds and found "+str(VALID_SEED_COUNT)+" valid seeds in "+str(TIME_SINCE)+" seconds." )
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(line)
if not wordlist_ok:
print(" Unknown words!" + line, file=sys.stderr)
continue
if not checksum_ok:
#print(" Checksum NOT OK!" + line, file=sys.stderr)
continue
#print(" Check passed. Queued: " + line)
VALID_SEED_COUNT+=1
t = threading.Thread(target=checkPassphrase, args=(line,))
threads.append(t)
t.start()
if len(threads) == MAX_THREADS:
for t in threads:
t.join()
threads.clear()
def test(self):
mnemonic = u'gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog'
is_checksum_valid, is_wordlist_valid = keystore.bip39_is_checksum_valid(mnemonic)
self.assertTrue(is_wordlist_valid)
self.assertTrue(is_checksum_valid)
def test(self):
mnemonic = u'gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog'
is_checksum_valid, is_wordlist_valid = keystore.bip39_is_checksum_valid(
mnemonic)
self.assertTrue(is_wordlist_valid)
self.assertTrue(is_checksum_valid)
import argparse
import sys
arg_parser = argparse.ArgumentParser()
arg_parser.add_argument('--no-check', action='store_true', default=False)
args = arg_parser.parse_args()
lines = [x.strip() for x in sys.stdin.readlines()]
words = ""
passw = ""
if len(lines) == 2:
passw = lines[1]
if not (len(lines) in [1, 2]):
print("wrong input", file=sys.stderr)
sys.exit(1)
words = lines[0]
if not args.no_check:
(checksum_ok, wordlist_ok) = keystore.bip39_is_checksum_valid(words)
if not wordlist_ok:
print("Unknown words!", file=sys.stderr)
sys.exit(1)
if not checksum_ok:
print("Checksum NOT OK!", file=sys.stderr)
sys.exit(1)
print(keystore.bip39_to_seed(words, passw).hex())
