Since you’ve gotten the checksum, and a majority of the phrases, I consider working with the binary or hex could be sooner.
I do not know the way a lot you recognize, or do not, so I’ll begin from the start, however I’ll maintain it easy by not together with data that’s not wanted for this activity.
A seed phrase is created through the use of a random variety of some size, between 128 bits to 256 bits. This quantity is then hashed, and a portion of it’s taken from the begining and extends the scale of the unique quantity.
These additional bits are the checksum.
For a seed phrase that’s 12 phrases lengthy, this checksum is 4 bits in size, and the unique quantity is 128 bits lengthy. For a complete of 132 bits.
Eleven bits are wanted to pick a phrase.
Having the final phrase means, not solely do you’ve gotten the checksum, you’ve gotten 7 different bits that precede it.
Your first three phrases being recognized, you even have the primary 33 bits so as.
I do query if you happen to imply you might be lacking the phrases 9, 10, and 11; or if these lacking phrases are supposed to be blended within the assorted recognized phrases. In your code, your order your phrases as such:
[first 3 words] [5 words assorted order] [random 2 words] [last word]
If that is so, I might
- convert my phrases into their numbers
- do a permutation on the recognized phrases (permutation will eradicate redundant checks)
- increment a quantity and append it for the lacking part (embody padding)
- append the primary 7 bits from the final phrase
- hash for checksum and examine returned checksum to authentic checksum
If I’ve a match, I would log this seed. However I would like do a test for a steadiness at the moment.
The explanation I might log them (be aware under on why I would not), and that is homework for you.
I do not know the way you went about going from seed to deal with once you created your tackle initially. I’m not assured that you’ll get an tackle match if you happen to stumbled upon your right seed with out this data. That is solely since you might need used a special device than you at the moment are, which can have used a special derivation path. The device you’ve gotten in your code makes use of:
DEFAULT_DERIVATION_PATH = "m/44'/394'/0'/0/0"
DEFAULT_BECH32_HRP = "cro"
Supply: https://github.com/crypto-org-chain/chainlibpy/blob/grasp/chainlibpy/pockets.py
Notice: A permutation of 5 phrases from a listing of 5 phrases will yield 120 iterations
To get via 33 lacking bits, you may undergo 8,589,934,592 rounds to complete that search house.
For a grand complete of 1,030,792,151,040 makes an attempt at max, if it occurred to be the final one, my pc ought to have the ability to end that whole house in an evening. This may be the explanation why you must determine how your seed phrases the place transformed to your tackle, on a nasty day with lengthy phrases, it might push into a number of terrabytes and take for much longer for all these reads and writes to disk.
from hashlib import sha256
from binascii import unhexlify
from itertools import permutations
#Wordlist, ideally you'd save as a file and import
#wordlist = [2048 words]
#Settings
FIRST_THREE = ["word", "word", "word"]
KNOWN_FIVE = ["word", "word", "word", "word", "word"]
# I saved as checklist so I haven't got to write down a dynamic operate to function on lists or strings
LAST_WORD = ["word"]
#Returns a listing of similar size with strings of binary with out the "0b" binary prefix
bin_formatter = lambda my_words: [format(wordlist.index(word), "011b") for word in my_words]
def predominant():
#Initialize setup
# 1. convert phrases into their numbers
main_section = {}
# First part will be joined as a result of it is not going to change
main_section["first_section"] = "".be part of(bin_formatter(FIRST_THREE))
# 2. Dealing with the permutation now, will be part of on every iteration
main_section["second_section"] = permutations(bin_formatter(KNOWN_FIVE), 5)
# 1.3 Final part is cut up into the 7 bits and checksum bits
main_section["last_section"] = {}
_temp_last_word = bin_formatter(LAST_WORD)[0]
main_section["last_section"]["primary_bits"], main_section["last_section"]["checksum"] = _temp_last_word[:7], _temp_last_word[7:]
#Fundamental loop over permutations
for ss in main_section["second_section"]:
# 3. increment a quantity and append it for the lacking part (embody padding)
for lacking in vary(8589934592):
#Utilizing format to exclude "0b" prefix; specifying so as to add sufficient 0's to make it 33 bits lengthy, zeros are added on left aspect
missing_binary = format(lacking, "033b")
# 4. append the primary 7 bits from the final phrase
binary_representation = main_section["first_section"] + "".be part of(ss) + missing_binary + main_section["last_section"]["primary_bits"]
#Hash prep
hex_representation = format(int(binary_representation, 2), "032x")
computer_ready_bytes = unhexlify(hex_representation)
# 5. hash for checksum and examine returned checksum to authentic checksum
hash_result = sha256(computer_ready_bytes).hexdigest()
#One hex image is equal to 4 bits, convert it to int then to binary with padding
checksum_result = format(int(hash_result[0], 16), '04b')
if main_section["last_section"]["checksum"] == checksum_result:
#append to file
#carry out affirmation steps
#whichever fits you
predominant()
Working Instance, practically similar code above, however with take a look at case built-in. Wordlist is imported, I put a gist with the english wordlist with “n” character stripped, place this file in similar folder and execute. https://gist.github.com/Gerschel/030f703deab4d47500748b7958f5c17c
from hashlib import sha256
from binascii import unhexlify
from itertools import permutations
#Check phrases
#['vague', 'salute', 'start', 'title', 'opinion', 'fancy', 'skate', 'arrange', 'meadow', 'absent', 'segment', 'blush']
#Lacking goal
goal = ["meadow", "absent", "segment"]
#Check bits
#'11110000101101111101101101010010111100010111100110110110101001011111001010000000011000101000100110100000000101110000110010001100'
#Check checksum
#'0100'
#Check full bits
#'111100001011011111011011010100101111000101111001101101101010010111110010100000000110001010001001101000000001011100001100100011000100'
#Wordlist, ideally you'd save as a file and import
from english import wordlist
#Settings
FIRST_THREE = ["vague", "salute", "start"]
KNOWN_FIVE = ["title", "opinion", "fancy", "skate", "arrange"]
# I saved as checklist so I haven't got to write down a dynamic operate to function on lists or strings
LAST_WORD = ["blush"]
#Returns a listing of similar size with strings of binary with out the "0b" binary prefix
bin_formatter = lambda my_words: [format(wordlist.index(word), "011b") for word in my_words]
def predominant():
#Initialize setup
# 1. convert phrases into their numbers
main_section = {}
# First part will be joined as a result of it is not going to change
main_section["first_section"] = "".be part of(bin_formatter(FIRST_THREE))
# 2. Dealing with the permutation now, will be part of on every iteration
main_section["second_section"] = permutations(bin_formatter(KNOWN_FIVE), 5)
# 1.3 Final part is cut up into the 7 bits and checksum bits
main_section["last_section"] = {}
_temp_last_word = bin_formatter(LAST_WORD)[0]
main_section["last_section"]["primary_bits"], main_section["last_section"]["checksum"] = _temp_last_word[:7], _temp_last_word[7:]
#Fundamental loop over permutations
discovered = False
for ss in main_section["second_section"]:
# 3. increment a quantity and append it for the lacking part (embody padding)
for lacking in vary(4615000000,4619000000):
#Utilizing format to exclude "0b" prefix; specifying so as to add sufficient 0's to make it 33 bits lengthy, zeros are added on left aspect
missing_binary = format(lacking, "033b")
# 4. append the primary 7 bits from the final phrase
binary_representation = main_section["first_section"] + "".be part of(ss) + missing_binary + main_section["last_section"]["primary_bits"]
#Hash prep
hex_representation = format(int(binary_representation, 2), "032x")
computer_ready_bytes = unhexlify(hex_representation)
# 5. hash for checksum and examine returned checksum to authentic checksum
hash_result = sha256(computer_ready_bytes).hexdigest()
#One hex image is equal to 4 bits, convert it to int then to binary with padding
checksum_result = format(int(hash_result[0], 16), '04b')
if main_section["last_section"]["checksum"] == checksum_result:
res_words = []
bits = binary_representation + checksum_result
for e in vary(0, len(bits), 11):
res_words.append(wordlist[int(bits[e: e+11], 2)])
if res_words[8:11] == goal:
discovered = True
break
print(f"Match: {res_words[8:11] == goal}tt {res_words[8:11]}", finish="r")
if discovered:
print(res_words)
break
predominant()