add bip85 app (#265)

* add bip85 app
* save to SD, load mnemonic to device

Author: stepansnigirev

src/apps/__init__.py

@@ -7,4 +7,5 @@
     "backup", # creates and loads backups (only loads for now)
     "blindingkeys", # blinding keys for liquid wallets
     "compatibility", # compatibility layer that converts json/files to Specter format
+    "bip85", # bip85 derivation of new mnemonics, xprvs etc
 ]

src/apps/bip85.py

@@ -0,0 +1,182 @@
+import lvgl as lv
+from binascii import hexlify
+from io import BytesIO
+
+from app import BaseApp, AppError
+from embit import bip85
+from gui.common import add_button, add_button_pair, align_button_pair
+from gui.decorators import on_release
+from gui.screens import Menu, NumericScreen, QRAlert, Alert
+from gui.screens.mnemonic import MnemonicScreen
+from helpers import SDCardFile
+
+class QRWithSD(QRAlert):
+    SAVE = 1
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        # add save button
+        btn = add_button("Save to SD card", on_release(self.save), scr=self)
+        btn.align(self.close_button, lv.ALIGN.OUT_TOP_MID, 0, -20)
+
+    def save(self):
+        self.set_value(self.SAVE)
+
+class Bip85MnemonicScreen(MnemonicScreen):
+    QR = 1
+    SD = 2
+    LOAD = 3
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.load_btn = add_button(
+            text="Use now (load to device)",
+            scr=self,
+            callback=on_release(self.load)
+        )
+        self.load_btn.align(self.table, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
+        self.show_qr_btn, self.save_sd_btn = add_button_pair(
+            text1="Show QR code",
+            callback1=on_release(self.show_qr),
+            text2="Save to SD card",
+            callback2=on_release(self.save_sd),
+            scr=self,
+        )
+        self.show_qr_btn.align(self.load_btn, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
+        self.save_sd_btn.align(self.load_btn, lv.ALIGN.OUT_BOTTOM_MID, 0, 10)
+        align_button_pair(self.show_qr_btn, self.save_sd_btn)
+
+    def show_qr(self):
+        self.set_value(self.QR)
+
+    def save_sd(self):
+        self.set_value(self.SD)
+
+    def load(self):
+        self.set_value(self.LOAD)
+
+class App(BaseApp):
+    """
+    WalletManager class manages your wallets.
+    It stores public information about the wallets
+    in the folder and signs it with keystore's id key
+    """
+
+    button = "Deterministic derivation (BIP-85)"
+    name = "bip85"
+
+    async def menu(self, show_screen):
+        buttons = [
+            (None, "Mnemonics"),
+            (0, "12-word mnemonic"),
+            (1, "18-word mnemonic"),
+            (2, "24-word mnemonic"),
+            (None, "Other stuff"),
+            (3, "WIF key (single private key)"),
+            (4, "Master private key (xprv)"),
+            (5, "Raw entropy (16-64 bytes)"),
+        ]
+
+        # wait for menu selection
+        menuitem = await show_screen(
+            Menu(
+                buttons,
+                last=(255, None),
+                title="What do you want to derive?",
+                note="",
+            )
+        )
+
+        # process the menu button:
+        # back button
+        if menuitem == 255:
+            return False
+        # get derivation index
+        index = await show_screen(
+            NumericScreen(title="Enter derivation index", note="Default: 0")
+        )
+        if index is None:
+            return True # stay in the menu
+        if index == "":
+            index = 0
+        index = int(index)
+        note = "index: %d" % index
+
+        fgp = hexlify(self.keystore.fingerprint).decode()
+        # mnemonic menu items
+        if menuitem >= 0 and menuitem <=2:
+            num_words = 12+6*menuitem
+            mnemonic = bip85.derive_mnemonic(
+                self.keystore.root, num_words=num_words, index=index
+            )
+            title = "Derived %d-word mnemonic" % num_words
+            action = await show_screen(
+                Bip85MnemonicScreen(mnemonic=mnemonic, title=title, note=note)
+            )
+            if action == Bip85MnemonicScreen.QR:
+                await show_screen(
+                    QRAlert(title=title, message=mnemonic, note=note)
+                )
+            elif action == Bip85MnemonicScreen.SD:
+                fname = "bip85-%s-mnemonic-%d-%d.txt" % (
+                    fgp, num_words, index
+                )
+                with SDCardFile(fname, "w") as f:
+                    f.write(mnemonic)
+                await show_screen(
+                    Alert(
+                        title="Success",
+                        message="Mnemonic is saved as\n\n%s" % fname,
+                        button_text="Close",
+                    )
+                )
+            elif action == Bip85MnemonicScreen.LOAD:
+                await self.communicate(
+                    BytesIO(b"set_mnemonic "+mnemonic.encode()), app="",
+                )
+                return False
+            return True
+        # other stuff
+        if menuitem == 3:
+            title = "Derived private key"
+            res = bip85.derive_wif(self.keystore.root, index)
+            file_suffix = "wif"
+        elif menuitem == 4:
+            title = "Derived master private key"
+            res = bip85.derive_xprv(self.keystore.root, index)
+            file_suffix = "xprv"
+        elif menuitem == 5:
+            num_bytes = await show_screen(
+                NumericScreen(
+                    title="Number of bytes to generate",
+                    note="16 <= N <= 64. Default: 32",
+                )
+            )
+            if num_bytes is None:
+                return True
+            if num_bytes == "":
+                num_bytes = 32
+            num_bytes = int(num_bytes)
+            if num_bytes < 16 or num_bytes > 64:
+                raise AppError("Only 16-64 bytes can be generated with BIP-85")
+            title = "Derived %d-byte entropy" % num_bytes
+            raw = bip85.derive_hex(self.keystore.root, num_bytes, index)
+            res = hexlify(raw).decode()
+            file_suffix = "hex-%d" % num_bytes
+        else:
+            raise NotImplementedError("Not implemented")
+        res = str(res)
+        action = await show_screen(
+            QRWithSD(title=title, message=res, note=note)
+        )
+        if action == QRWithSD.SAVE:
+            fname = "bip85-%s-%s-%d.txt" % (fgp, file_suffix, index)
+            with SDCardFile(fname, "w") as f:
+                f.write(res)
+            await show_screen(
+                Alert(
+                    title="Success",
+                    message="Data is saved as\n\n%s" % fname,
+                    button_text="Close",
+                )
+            )
+        return True
+

src/gui/common.py

@@ -169,6 +169,7 @@ def align_button_pair(btn1, btn2):
     w = (HOR_RES - 3 * PADDING) // 2
     btn1.set_width(w)
     btn2.set_width(w)
+    btn1.set_x(PADDING)
     btn2.set_x(HOR_RES // 2 + PADDING // 2)
 
 

src/gui/screens/input.py

@@ -414,12 +414,15 @@ class NumericScreen(Screen):
     def __init__(
             self,
             title="Enter account number",
+            note=None,
             current_val='0'
     ):
         super().__init__()
+        if note is None:
+            note = "Current account number: %s" % current_val
         self.title = add_label(title, scr=self, y=PADDING, style="title")
 
-        self.note = add_label("Current account number: %s" % current_val, scr=self, style="hint")
+        self.note = add_label(note, scr=self, style="hint")
         self.note.align(self.title, lv.ALIGN.OUT_BOTTOM_MID, 0, 5)
 
         self.kb = lv.btnm(self)

src/gui/specter.py

@@ -7,7 +7,6 @@
     RecoverMnemonicScreen,
     DevSettings,
 )
-import rng
 import asyncio
 
 

src/keystore/ram.py

@@ -1,8 +1,7 @@
-from .core import KeyStore, KeyStoreError, PinError
+from .core import KeyStore, KeyStoreError
 from platform import CriticalErrorWipeImmediately
 import platform
 from rng import get_random_bytes
-import hashlib
 import hmac
 from embit import ec, bip39, bip32
 from embit.liquid import slip77

src/specter.py

@@ -6,11 +6,8 @@
 
 from platform import (
     CriticalErrorWipeImmediately,
-    set_usb_mode,
     reboot,
-    fpath,
     maybe_mkdir,
-    file_exists,
     wipe,
     get_version,
     get_battery_status,
@@ -23,7 +20,7 @@
 from gui.screens.mnemonic import MnemonicPrompt
 
 # small helper functions
-from helpers import gen_mnemonic, fix_mnemonic, load_apps, is_liquid
+from helpers import gen_mnemonic, fix_mnemonic
 from errors import BaseError
 
 
@@ -143,7 +140,7 @@ async def host_exception_handler(self, e):
             b = BytesIO()
             sys.print_exception(e, b)
             msg = b.getvalue().decode()
-        res = await self.gui.error(msg, popup=True)
+        await self.gui.error(msg, popup=True)
 
     async def main(self):
         while True:
@@ -166,6 +163,22 @@ def init_apps(self):
             app.init(self.keystore, self.network, self.gui.show_loader, self.cross_app_communicate)
 
     async def cross_app_communicate(self, stream, app:str=None, show_fn=None):
+        if app == "": # root
+            data = stream.read()
+            if data.startswith(b"set_mnemonic "):
+                mnemonic = data[len("set_mnemonic "):].decode()
+                confirm = await self.gui.prompt(
+                        "Load new mnemonic?",
+                        "\nApp requested to load new mnemonic\n"
+                        "Do you want to continue?\n\n"
+                        "You will need to reboot the device to get back"
+                        " to your current mnemonic.",
+                )
+                if confirm:
+                    return self.set_mnemonic(mnemonic)
+                else:
+                    return True
+            raise SpecterError("Invalid command '%s'" % data)
         return await self.process_host_request(stream, popup=False, appname=app, show_fn=show_fn)
 
     async def initmenu(self):
@@ -194,20 +207,15 @@ async def initmenu(self):
             mnemonic = await self.gui.new_mnemonic(gen_mnemonic, bip39.WORDLIST, fix_mnemonic)
             if mnemonic is not None:
                 # load keys using mnemonic and empty password
-                self.keystore.set_mnemonic(mnemonic.strip(), "")
-                self.init_apps()
-                return self.mainmenu
+                return self.set_mnemonic(mnemonic, "")
         # recover
         elif menuitem == 1:
             mnemonic = await self.gui.recover(
                 bip39.mnemonic_is_valid, bip39.find_candidates, fix_mnemonic
             )
             if mnemonic is not None:
                 # load keys using mnemonic and empty password
-                self.keystore.set_mnemonic(mnemonic, "")
-                self.init_apps()
-                self.current_menu = self.mainmenu
-                return self.mainmenu
+                return self.set_mnemonic(mnemonic, "")
         elif menuitem == 2:
             # try to load key, if user cancels -> return
             res = await self.keystore.load_mnemonic()
@@ -256,7 +264,10 @@ async def import_mnemonic(self):
         # confirm mnemonic
         if not await self.gui.show_screen()(scr):
             return
-        self.keystore.set_mnemonic(mnemonic, "")
+        return self.set_mnemonic(mnemonic, "")
+
+    def set_mnemonic(self, mnemonic, password=""):
+        self.keystore.set_mnemonic(mnemonic.strip(), password)
         self.init_apps()
         self.current_menu = self.mainmenu
         return self.mainmenu