def process_single(mnemonic: str) -> bytes: """ Receives single mnemonic and processes it. Returns what is then stored in storage or None if more shares are needed. """ identifier, iteration_exponent, _, _, _, index, threshold, value = slip39.decode_mnemonic( mnemonic) # TODO: use better data structure for this if threshold == 1: raise ValueError("Threshold equal to 1 is not allowed.") # if recovery is not in progress already, start it and wait for more mnemonics if not storage.is_slip39_in_progress(): storage.set_slip39_in_progress(True) storage.set_slip39_iteration_exponent(iteration_exponent) storage.set_slip39_identifier(identifier) storage.set_slip39_threshold(threshold) storage.set_slip39_remaining(threshold - 1) storage.set_slip39_words_count(len(mnemonic.split())) storage.set_slip39_mnemonic(index, mnemonic) return None # we need more shares # check identifier and member index of this share against stored values if identifier != storage.get_slip39_identifier(): # TODO: improve UX (tell user) raise ValueError("Share identifiers do not match") if storage.get_slip39_mnemonic(index): # TODO: improve UX (tell user) raise ValueError("This mnemonic was already entered") # append to storage remaining = storage.get_slip39_remaining() - 1 storage.set_slip39_remaining(remaining) storage.set_slip39_mnemonic(index, mnemonic) if remaining != 0: return None # we need more shares # combine shares and return the master secret mnemonics = storage.get_slip39_mnemonics() if len(mnemonics) != threshold: raise ValueError("Some mnemonics are still missing.") _, _, secret = slip39.combine_mnemonics(mnemonics) return secret
async def recovery_device(ctx, msg): """ Recover BIP39/SLIP39 seed into empty device. 1. Ask for the number of words in recovered seed. 2. Let user type in the mnemonic words one by one. 3. Optionally check the seed validity. 4. Optionally ask for the PIN, with confirmation. 5. Save into storage. """ if not msg.dry_run and storage.is_initialized(): raise wire.UnexpectedMessage("Already initialized") if not storage.is_slip39_in_progress(): if not msg.dry_run: title = "Wallet recovery" text = Text(title, ui.ICON_RECOVERY) text.normal("Do you really want to", "recover the wallet?", "") else: title = "Simulated recovery" text = Text(title, ui.ICON_RECOVERY) text.normal("Do you really want to", "check the recovery", "seed?") await require_confirm(ctx, text, code=ButtonRequestType.ProtectCall) if msg.dry_run: if config.has_pin(): curpin = await request_pin_ack(ctx, "Enter PIN", config.get_pin_rem()) else: curpin = "" if not config.check_pin(pin_to_int(curpin)): raise wire.PinInvalid("PIN invalid") # ask for the number of words wordcount = await request_wordcount(ctx, title) mnemonic_module = mnemonic.module_from_words_count(wordcount) else: wordcount = storage.get_slip39_words_count() mnemonic_module = mnemonic.slip39 if mnemonic_module == mnemonic.slip39: # show a note about the keyboard await show_keyboard_info(ctx) if msg.dry_run: dry_run_mnemonics = [] dry_run_mnemonic_count = None secret = None while secret is None: # ask for mnemonic words one by one words = await request_mnemonic(ctx, wordcount, mnemonic_module == mnemonic.slip39) try: if msg.dry_run: if dry_run_mnemonic_count is None: dry_run_mnemonic_count = mnemonic_module.get_mnemonic_count( words) dry_run_mnemonics.append(words) else: secret = mnemonic_module.process_single(words) except slip39.MnemonicError as e: raise wire.ProcessError("Mnemonic is not valid: " + str(e)) if msg.dry_run: remaining = dry_run_mnemonic_count - len(dry_run_mnemonics) if remaining == 0: secret = mnemonic_module.process_all(dry_run_mnemonics) else: remaining = storage.get_slip39_remaining() # show a number of remaining mnemonics for SLIP39 if secret is None and mnemonic_module == mnemonic.slip39: await show_remaining_slip39_mnemonics(ctx, title, remaining) # check mnemonic validity # it is checked automatically in SLIP-39 if mnemonic_module == mnemonic.bip39 and (msg.enforce_wordlist or msg.dry_run): if not mnemonic_module.check(secret): raise wire.ProcessError("Mnemonic is not valid") # ask for pin repeatedly if msg.pin_protection: newpin = await request_pin_confirm(ctx, allow_cancel=False) else: newpin = "" # dry run if msg.dry_run: return mnemonic.dry_run(secret) # save into storage if msg.pin_protection: config.change_pin(pin_to_int(""), pin_to_int(newpin)) storage.set_u2f_counter(msg.u2f_counter) storage.load_settings(label=msg.label, use_passphrase=msg.passphrase_protection) mnemonic_module.store(secret=secret, needs_backup=False, no_backup=False) await show_success(ctx) display_homescreen() return Success(message="Device recovered")