def save_settings(self, settings, fname=None):
maybe_mkdir(self.SETTINGS_DIR)
if fname is None:
fname = self.settings_fname
self.keystore.save_aead(fname,
adata=json.dumps(settings).encode(),
key=self.keystore.settings_key)
def load_config(self):
try:
config, _ = self.keystore.load_aead(
self.path + "/settings", self.keystore.enc_secret
)
config = json.loads(config.decode())
except Exception as e:
print(e)
config = {"dev": self.dev, "usb": self.usb}
self.keystore.save_aead(
self.path + "/settings",
adata=json.dumps(config).encode(),
key=self.keystore.enc_secret,
)
self.dev = config["dev"]
self.usb = config["usb"]
# add apps in dev mode
if self.dev:
try:
qspi = fpath("/qspi/extensions")
maybe_mkdir(qspi)
maybe_mkdir(qspi + "/extra_apps")
if qspi not in sys.path:
sys.path.append(qspi)
self.apps += load_apps("extra_apps")
except Exception as e:
print(e)
def tempdir(self):
if self.TEMPDIR is None:
return None
maybe_mkdir(self.TEMPDIR)
path = self.TEMPDIR + "/" + type(self).__name__
maybe_mkdir(path)
return path
def add_wallet(self, w):
self.wallets.append(w)
wallet_ids = sorted([int(f[0]) for f in os.ilistdir(self.path) \
if f[0].isdigit() and f[1] == 0x4000])
newpath = self.path + ("/%d" % (max(wallet_ids) + 1))
platform.maybe_mkdir(newpath)
w.save(self.keystore, path=newpath)
def __init__(self, path):
# storage for data
self.path = path
maybe_mkdir(path)
# set manager
self.manager = None
# check this flag in update function
# if disabled - throw all incoming data
self.enabled = False
self.initialized = False
async def init(self, show_fn):
"""
Waits for keystore media
and loads internal secret and PIN state
"""
self.show = show_fn
platform.maybe_mkdir(self.path)
self.load_secret(self.path)
self.load_state()
# the rest we can get from parent
await super().init(show_fn)
async def init(self, show_fn):
"""
Waits for keystore media
and loads internal secret and PIN state
"""
self.show = show_fn
platform.maybe_mkdir(self.path)
self.load_secret(self.path)
await self.check_card()
# the rest can be done with parent
await super().init(show_fn)
def __init__(self, desc, path=None, name="Untitled"):
self.name = name
self.path = path
if self.path is not None:
self.path = self.path.rstrip("/")
maybe_mkdir(self.path)
self.descriptor = desc
# receive and change gap limits
self.gaps = [self.GAP_LIMIT for b in range(self.descriptor.num_branches)]
self.name = name
self.unused_recv = 0
self.keystore = None
def save(self, keystore, path=None):
# wallet has access to keystore only if it's saved or loaded from file
self.keystore = keystore
if path is not None:
self.path = path.rstrip("/")
if self.path is None:
raise WalletError("Path is not defined")
maybe_mkdir(self.path)
desc = str(self.descriptor)
keystore.save_aead(self.path + "/descriptor", plaintext=desc.encode())
obj = {"gaps": self.gaps, "name": self.name, "unused_recv": self.unused_recv}
meta = json.dumps(obj).encode()
keystore.save_aead(self.path + "/meta", plaintext=meta)
def load_wallets(self):
"""Loads all wallets from path"""
try:
platform.maybe_mkdir(self.path)
# get ids of the wallets - every wallet is stored in a numeric folder
wallet_ids = sorted([int(f[0]) for f in os.ilistdir(self.path) \
if f[0].isdigit() and f[1] == 0x4000])
return [
self.load_wallet(self.path + ("/%d" % wid))
for wid in wallet_ids
]
except:
return []
def get_keystore(mnemonic="ability " * 11 + "acid", password=""):
"""Returns a dummy keystore"""
platform.maybe_mkdir(TEST_DIR)
platform.maybe_mkdir(TEST_DIR + "/keystore")
ks = RAMKeyStore()
ks.path = TEST_DIR + "/keystore"
ks.show_loader = show_loader
ks.show = show
ks.load_secret(ks.path)
ks.initialized = True
ks._unlock("1234")
ks.set_mnemonic(mnemonic, password)
return ks
def __init__(self, path):
# storage for data
self.path = path
maybe_mkdir(path)
if self.SETTINGS_DIR:
maybe_mkdir(self.SETTINGS_DIR)
# set manager
self.manager = None
# check this flag in update function
# if disabled - throw all incoming data
self.enabled = False
self.initialized = False
# default settings, extend it with more settings if applicable
self.settings = {"enabled": True}
def save(self, keystore, path=None):
if path is not None:
self.path = path.rstrip("/")
if self.path is None:
raise WalletError("Path is not defined")
maybe_mkdir(self.path)
desc = self.descriptor()
keystore.save_aead(self.path + "/descriptor", plaintext=desc.encode())
obj = {
"gaps": self.gaps,
"name": self.name,
"unused_recv": self.unused_recv
}
meta = json.dumps(obj).encode()
keystore.save_aead(self.path + "/meta", plaintext=meta)
def __init__(self, script, wrapped=False, path=None, name="Untitled"):
self.name = name
self.path = path
if self.path is not None:
self.path = self.path.rstrip("/")
maybe_mkdir(self.path)
if type(script) not in type(self).SCRIPTS:
raise WalletError("%s not in %s" %
(type(script), type(self).SCRIPTS))
self.script = script
self.wrapped = wrapped
# receive and change gap limits
self.gaps = [self.GAP_LIMIT, self.GAP_LIMIT]
self.name = name
self.unused_recv = 0
def init(self, keystore, network="test"):
"""Loads or creates default wallets for new keystore or network"""
self.keystore = keystore
# add fingerprint dir
path = self.root_path + "/" + hexlify(self.keystore.fingerprint).decode()
platform.maybe_mkdir(path)
if network not in NETWORKS:
raise WalletError("Invalid network")
self.network = network
# add network dir
path += "/" + network
platform.maybe_mkdir(path)
self.path = path
self.wallets = self.load_wallets()
if self.wallets is None or len(self.wallets) == 0:
w = self.create_default_wallet(path=self.path + "/0")
self.wallets = [w]
async def init(self, show_fn):
"""
Waits for keystore media
and loads internal secret and PIN state
"""
self.show = show_fn
platform.maybe_mkdir(self.path)
self.load_secret(self.path)
self.load_state()
# check if init is called for the first time
# and we have less than max PIN attempts
if (not self.initialized
and self.pin_attempts_left != self.pin_attempts_max):
scr = Alert("Warning!",
"You only have %d of %d attempts\n"
"to enter correct PIN code!" %
(self.pin_attempts_left, self.pin_attempts_max),
button_text="OK")
await self.show(scr)
self.initialized = True
def get_wallets_app(keystore, network):
platform.maybe_mkdir(TEST_DIR)
platform.maybe_mkdir(TEST_DIR + "/wallets")
platform.maybe_mkdir(TEST_DIR + "/tmp")
BaseApp.tempdir = TEST_DIR + "/tmp"
wapp = WalletsApp(TEST_DIR + "/wallets")
wapp.init(keystore, network, show_loader, communicate)
return wapp
def init_keystore(ks):
platform.maybe_mkdir(ks.path)
ks.load_secret(ks.path)
ks.load_state()
ks.initialized = True
def main(apps=None, network="main", keystore_cls=None):
"""
apps: list of apps to load
network: default network to operate
keystores: list of KeyStore classes that can be used
"""
# Init display first as it also inits the SDRAM
display.init(False)
# create virtual file system /sdram
# for temp untrusted data storage
rampath = platform.mount_sdram()
# set working path to empty folder in sdram
if not platform.simulator:
cwd = rampath + "/cwd"
platform.maybe_mkdir(cwd)
os.chdir(cwd)
# define hosts - USB, QR, SDCard
# each hosts gets it's own RAM folder for data
Host.SETTINGS_DIR = platform.fpath("/qspi/hosts")
Specter.SETTINGS_DIR = platform.fpath("/qspi/global")
hosts = [
USBHost(rampath + "/usb"),
QRHost(rampath + "/qr"),
SDHost(rampath + "/sd"),
]
# temp storage in RAM for host commands processing
BaseApp.TEMPDIR = rampath + "/tmp"
# define GUI
if not platform.simulator:
gui = SpecterGUI()
else:
# this GUI can simulate user actions for automated testing
from gui.tcp_gui import TCPGUI
gui = TCPGUI()
# inject the folder where keystore stores it's data
KeyStore.path = platform.fpath("/flash/keystore")
# detect keystore to use
if keystore_cls is not None:
keystores = [keystore_cls]
else:
keystores = [
MemoryCard,
SDKeyStore,
]
# loading apps
if apps is None:
apps = load_apps()
# make Specter instance
settings_path = platform.fpath("/flash")
specter = Specter(
gui=gui,
keystores=keystores,
hosts=hosts,
apps=apps,
settings_path=settings_path,
network=network,
)
specter.start()
def init(self):
"""Load internal secret and PIN state"""
platform.maybe_mkdir(self.path)
self.load_secret(self.path)
self.load_state()
def __init__(self, path: str):
"""path is the folder where this app should store data"""
maybe_mkdir(path)
self.path = path
def __init__(self, path):
self.root_path = path
platform.maybe_mkdir(path)
self.path = None
self.wallets = []
def __init__(self, path):
self.root_path = path
platform.maybe_mkdir(path)
self.path = None
self.manager = None
