autosign.py 27 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910
  1. #!/usr/bin/env python3
  2. #
  3. # MMGen Wallet, a terminal-based cryptocurrency wallet
  4. # Copyright (C)2013-2024 The MMGen Project <mmgen@tuta.io>
  5. # Licensed under the GNU General Public License, Version 3:
  6. # https://www.gnu.org/licenses
  7. # Public project repositories:
  8. # https://github.com/mmgen/mmgen-wallet
  9. # https://gitlab.com/mmgen/mmgen-wallet
  10. """
  11. autosign: Auto-sign MMGen transactions, message files and XMR wallet output files
  12. """
  13. import sys, os, asyncio
  14. from stat import S_IWUSR, S_IRUSR
  15. from pathlib import Path
  16. from subprocess import run, PIPE, DEVNULL
  17. from .cfg import Config
  18. from .util import msg, msg_r, ymsg, rmsg, gmsg, bmsg, die, suf, fmt, fmt_list, is_int, have_sudo, capfirst
  19. from .color import yellow, red, orange, brown, blue
  20. from .wallet import Wallet,get_wallet_cls
  21. from .addrlist import AddrIdxList
  22. from .filename import find_file_in_dir
  23. from .ui import keypress_confirm
  24. def SwapMgr(*args, **kwargs):
  25. if sys.platform == 'linux':
  26. return SwapMgrLinux(*args, **kwargs)
  27. elif sys.platform == 'darwin':
  28. return SwapMgrMacOS(*args, **kwargs)
  29. class SwapMgrBase:
  30. def __init__(self, cfg, ignore_zram=False):
  31. self.cfg = cfg
  32. self.ignore_zram = ignore_zram
  33. self.desc = 'disk swap' if ignore_zram else 'swap'
  34. def enable(self, quiet=False):
  35. ret = self.do_enable()
  36. if not quiet:
  37. self.cfg._util.qmsg(
  38. f'{capfirst(self.desc)} successfully enabled' if ret else
  39. f'{capfirst(self.desc)} is already enabled' if ret is None else
  40. f'Could not enable {self.desc}')
  41. return ret
  42. def disable(self, quiet=False):
  43. self.cfg._util.qmsg_r(f'Attempting to disable {self.desc}...')
  44. ret = self.do_disable()
  45. self.cfg._util.qmsg('success')
  46. if not quiet:
  47. self.cfg._util.qmsg(
  48. f'{capfirst(self.desc)} successfully disabled ({fmt_list(ret, fmt="no_quotes")})'
  49. if ret and isinstance(ret, list) else
  50. f'{capfirst(self.desc)} successfully disabled' if ret else
  51. f'No active {self.desc}')
  52. return ret
  53. def process_cmds(self, op, cmds):
  54. if not cmds:
  55. return
  56. if have_sudo(silent=True) and not self.cfg.test_suite:
  57. for cmd in cmds:
  58. run(cmd.split(), check=True)
  59. else:
  60. pre = 'failure\n' if op == 'disable' else ''
  61. fs = blue('{a} {b} manually by executing the following command{c}:\n{d}')
  62. post = orange('[To prevent this message in the future, enable sudo without a password]')
  63. m = pre + fs.format(
  64. a = 'Please disable' if op == 'disable' else 'Enable',
  65. b = self.desc,
  66. c = suf(cmds),
  67. d = fmt_list(cmds, indent=' ', fmt='col')) + '\n' + post
  68. msg(m)
  69. if not self.cfg.test_suite:
  70. sys.exit(1)
  71. class SwapMgrLinux(SwapMgrBase):
  72. def get_active(self):
  73. cp = run(['/sbin/swapon', '--show=NAME', '--noheadings'], stdout=PIPE, text=True, check=True)
  74. res = cp.stdout.splitlines()
  75. return [e for e in res if not e.startswith('/dev/zram')] if self.ignore_zram else res
  76. def do_enable(self):
  77. if ret := self.get_active():
  78. ymsg(f'Warning: {self.desc} is already enabled: ({fmt_list(ret, fmt="no_quotes")})')
  79. self.process_cmds('enable', ['sudo swapon --all'])
  80. return True
  81. def do_disable(self):
  82. swapdevs = self.get_active()
  83. if not swapdevs:
  84. return None
  85. self.process_cmds('disable', [f'sudo swapoff {swapdev}' for swapdev in swapdevs])
  86. return swapdevs
  87. class SwapMgrMacOS(SwapMgrBase):
  88. def get_active(self):
  89. cmd = 'launchctl print system/com.apple.dynamic_pager'
  90. return run(cmd.split(), stdout=DEVNULL, stderr=DEVNULL).returncode == 0
  91. def _do_action(self, active, op, cmd):
  92. if self.get_active() is active:
  93. return None
  94. else:
  95. cmd = f'sudo launchctl {cmd} -w /System/Library/LaunchDaemons/com.apple.dynamic_pager.plist'
  96. self.process_cmds(op, [cmd])
  97. return True
  98. def do_enable(self):
  99. return self._do_action(active=True, op='enable', cmd='load')
  100. def do_disable(self):
  101. return self._do_action(active=False, op='disable', cmd='unload')
  102. class Signable:
  103. non_xmr_signables = (
  104. 'transaction',
  105. 'automount_transaction',
  106. 'message')
  107. xmr_signables = ( # order is important!
  108. 'xmr_wallet_outputs_file', # import XMR wallet outputs BEFORE signing transactions
  109. 'xmr_transaction')
  110. class base:
  111. clean_all = False
  112. multiple_ok = True
  113. action_desc = 'signed'
  114. def __init__(self,parent):
  115. self.parent = parent
  116. self.cfg = parent.cfg
  117. self.dir = getattr(parent,self.dir_name)
  118. self.name = type(self).__name__
  119. @property
  120. def submitted(self):
  121. return self._processed('_submitted', self.subext)
  122. def _processed(self, attrname, ext):
  123. if not hasattr(self, attrname):
  124. setattr(self, attrname, tuple(f for f in sorted(self.dir.iterdir()) if f.name.endswith('.'+ext)))
  125. return getattr(self, attrname)
  126. @property
  127. def unsigned(self):
  128. return self._unprocessed( '_unsigned', self.rawext, self.sigext )
  129. @property
  130. def unsubmitted(self):
  131. return self._unprocessed( '_unsubmitted', self.sigext, self.subext )
  132. @property
  133. def unsubmitted_raw(self):
  134. return self._unprocessed( '_unsubmitted_raw', self.rawext, self.subext )
  135. unsent = unsubmitted
  136. unsent_raw = unsubmitted_raw
  137. def _unprocessed(self,attrname,rawext,sigext):
  138. if not hasattr(self,attrname):
  139. dirlist = sorted(self.dir.iterdir())
  140. names = {f.name for f in dirlist}
  141. setattr(
  142. self,
  143. attrname,
  144. tuple(f for f in dirlist
  145. if f.name.endswith('.' + rawext)
  146. and f.name[:-len(rawext)] + sigext not in names) )
  147. return getattr(self,attrname)
  148. def print_bad_list(self,bad_files):
  149. msg('\n{a}\n{b}'.format(
  150. a = red(f'Failed {self.desc}s:'),
  151. b = ' {}\n'.format('\n '.join(self.gen_bad_list(sorted(bad_files,key=lambda f: f.name))))
  152. ))
  153. def die_wrong_num_txs(self, tx_type, msg=None, desc=None, show_dir=False):
  154. num_txs = len(getattr(self, tx_type))
  155. die('AutosignTXError', "{m}{a} {b} transaction{c} {d} {e}!".format(
  156. m = msg + '\n' if msg else '',
  157. a = 'One' if num_txs == 1 else 'More than one' if num_txs else 'No',
  158. b = desc or tx_type,
  159. c = suf(num_txs),
  160. d = 'already present' if num_txs else 'present',
  161. e = f'in ‘{getattr(self.parent, self.dir_name)}’' if show_dir else 'on removable device',
  162. ))
  163. def check_create_ok(self):
  164. if len(self.unsigned):
  165. self.die_wrong_num_txs('unsigned', msg='Cannot create transaction')
  166. if len(self.unsent):
  167. die('AutosignTXError', 'Cannot create transaction: you have an unsent transaction')
  168. def get_unsubmitted(self, tx_type='unsubmitted'):
  169. if len(self.unsubmitted) == 1:
  170. return self.unsubmitted[0]
  171. else:
  172. self.die_wrong_num_txs(tx_type)
  173. def get_unsent(self):
  174. return self.get_unsubmitted('unsent')
  175. def get_submitted(self):
  176. if len(self.submitted) == 0:
  177. self.die_wrong_num_txs('submitted')
  178. else:
  179. return self.submitted
  180. def get_abortable(self):
  181. if len(self.unsent_raw) != 1:
  182. self.die_wrong_num_txs('unsent_raw', desc='unsent')
  183. if len(self.unsent) > 1:
  184. self.die_wrong_num_txs('unsent')
  185. if self.unsent:
  186. if self.unsent[0].stem != self.unsent_raw[0].stem:
  187. die(1, f'{self.unsent[0]}, {self.unsent_raw[0]}: file mismatch')
  188. return self.unsent_raw + self.unsent
  189. def shred_abortable(self):
  190. files = self.get_abortable() # raises AutosignTXError if no unsent TXs available
  191. if keypress_confirm(
  192. self.cfg,
  193. 'The following file{} will be securely deleted:\n{}\nOK?'.format(
  194. suf(files),
  195. fmt_list(map(str, files), fmt='col', indent=' '))):
  196. for f in files:
  197. msg(f'Shredding file ‘{f}’')
  198. from .fileutil import shred_file
  199. shred_file(f)
  200. sys.exit(0)
  201. else:
  202. die(1, 'Exiting at user request')
  203. async def get_last_created(self):
  204. from .tx import CompletedTX
  205. ext = '.' + Signable.automount_transaction.subext
  206. files = [f for f in self.dir.iterdir() if f.name.endswith(ext)]
  207. return sorted(
  208. [await CompletedTX(cfg=self.cfg, filename=str(txfile), quiet_open=True) for txfile in files],
  209. key = lambda x: x.timestamp)[-1]
  210. class transaction(base):
  211. desc = 'non-automount transaction'
  212. rawext = 'rawtx'
  213. sigext = 'sigtx'
  214. dir_name = 'tx_dir'
  215. fail_msg = 'failed to sign'
  216. async def sign(self,f):
  217. from .tx import UnsignedTX
  218. tx1 = UnsignedTX(
  219. cfg = self.cfg,
  220. filename = f,
  221. automount = self.name=='automount_transaction')
  222. if tx1.proto.sign_mode == 'daemon':
  223. from .rpc import rpc_init
  224. tx1.rpc = await rpc_init( self.cfg, tx1.proto, ignore_wallet=True )
  225. from .tx.sign import txsign
  226. tx2 = await txsign(
  227. cfg_parm = self.cfg,
  228. tx = tx1,
  229. seed_files = self.parent.wallet_files[:],
  230. kl = None,
  231. kal = None,
  232. passwd_file = str(self.parent.keyfile))
  233. if tx2:
  234. tx2.file.write(ask_write=False, outdir=self.dir)
  235. return tx2
  236. else:
  237. return False
  238. def print_summary(self,signables):
  239. if self.cfg.full_summary:
  240. bmsg('\nAutosign summary:\n')
  241. msg_r('\n'.join(tx.info.format(terse=True) for tx in signables))
  242. return
  243. def gen():
  244. for tx in signables:
  245. non_mmgen = [o for o in tx.outputs if not o.mmid]
  246. if non_mmgen:
  247. yield (tx,non_mmgen)
  248. body = list(gen())
  249. if body:
  250. bmsg('\nAutosign summary:')
  251. fs = '{} {} {}'
  252. t_wid,a_wid = 6,44
  253. def gen():
  254. yield fs.format('TX ID ','Non-MMGen outputs'+' '*(a_wid-17),'Amount')
  255. yield fs.format('-'*t_wid, '-'*a_wid, '-'*7)
  256. for tx,non_mmgen in body:
  257. for nm in non_mmgen:
  258. yield fs.format(
  259. tx.txid.fmt( width=t_wid, color=True ) if nm is non_mmgen[0] else ' '*t_wid,
  260. nm.addr.fmt(nm.addr.view_pref, width=a_wid, color=True),
  261. nm.amt.hl() + ' ' + yellow(tx.coin))
  262. msg('\n' + '\n'.join(gen()))
  263. else:
  264. msg('\nNo non-MMGen outputs')
  265. def gen_bad_list(self,bad_files):
  266. for f in bad_files:
  267. yield red(f.name)
  268. class automount_transaction(transaction):
  269. desc = 'automount transaction'
  270. dir_name = 'txauto_dir'
  271. rawext = 'arawtx'
  272. sigext = 'asigtx'
  273. subext = 'asubtx'
  274. multiple_ok = False
  275. class xmr_signable(transaction): # mixin class
  276. def need_daemon_restart(self,m,new_idx):
  277. old_idx = self.parent.xmr_cur_wallet_idx
  278. self.parent.xmr_cur_wallet_idx = new_idx
  279. return old_idx != new_idx or m.wd.state != 'ready'
  280. def print_summary(self,signables):
  281. bmsg('\nAutosign summary:')
  282. msg('\n'.join(s.get_info(indent=' ') for s in signables) + self.summary_footer)
  283. class xmr_transaction(xmr_signable):
  284. dir_name = 'xmr_tx_dir'
  285. desc = 'Monero transaction'
  286. subext = 'subtx'
  287. multiple_ok = False
  288. summary_footer = ''
  289. async def sign(self,f):
  290. from . import xmrwallet
  291. from .xmrwallet.file.tx import MoneroMMGenTX
  292. tx1 = MoneroMMGenTX.Completed(self.parent.xmrwallet_cfg, f)
  293. m = xmrwallet.op(
  294. 'sign',
  295. self.parent.xmrwallet_cfg,
  296. infile = str(self.parent.wallet_files[0]), # MMGen wallet file
  297. wallets = str(tx1.src_wallet_idx))
  298. tx2 = await m.main( f, restart_daemon=self.need_daemon_restart(m,tx1.src_wallet_idx) )
  299. tx2.write(ask_write=False)
  300. return tx2
  301. class xmr_wallet_outputs_file(xmr_signable):
  302. desc = 'Monero wallet outputs file'
  303. rawext = 'raw'
  304. sigext = 'sig'
  305. dir_name = 'xmr_outputs_dir'
  306. clean_all = True
  307. summary_footer = '\n'
  308. @property
  309. def unsigned(self):
  310. import json
  311. return tuple(
  312. f for f in super().unsigned
  313. if not json.loads(f.read_text())['MoneroMMGenWalletOutputsFile']['data']['imported'])
  314. async def sign(self,f):
  315. from . import xmrwallet
  316. wallet_idx = xmrwallet.op_cls('wallet').get_idx_from_fn(f)
  317. m = xmrwallet.op(
  318. 'import_outputs',
  319. self.parent.xmrwallet_cfg,
  320. infile = str(self.parent.wallet_files[0]), # MMGen wallet file
  321. wallets = str(wallet_idx))
  322. obj = await m.main(f, wallet_idx, restart_daemon=self.need_daemon_restart(m,wallet_idx))
  323. obj.write(quiet=not obj.data.sign)
  324. self.action_desc = 'imported and signed' if obj.data.sign else 'imported'
  325. return obj
  326. class message(base):
  327. desc = 'message file'
  328. rawext = 'rawmsg.json'
  329. sigext = 'sigmsg.json'
  330. dir_name = 'msg_dir'
  331. fail_msg = 'failed to sign or signed incompletely'
  332. async def sign(self,f):
  333. from .msg import UnsignedMsg,SignedMsg
  334. m = UnsignedMsg( self.cfg, infile=f )
  335. await m.sign(wallet_files=self.parent.wallet_files[:], passwd_file=str(self.parent.keyfile))
  336. m = SignedMsg( self.cfg, data=m.__dict__ )
  337. m.write_to_file(
  338. outdir = self.dir.resolve(),
  339. ask_overwrite = False )
  340. if m.data.get('failed_sids'):
  341. die('MsgFileFailedSID',f'Failed Seed IDs: {fmt_list(m.data["failed_sids"],fmt="bare")}')
  342. return m
  343. def print_summary(self,signables):
  344. gmsg('\nSigned message files:')
  345. for message in signables:
  346. gmsg(' ' + message.signed_filename)
  347. def gen_bad_list(self,bad_files):
  348. for f in bad_files:
  349. sigfile = f.parent / ( f.name[:-len(self.rawext)] + self.sigext )
  350. yield orange(sigfile.name) if sigfile.exists() else red(f.name)
  351. class Autosign:
  352. dev_label = 'MMGEN_TX'
  353. linux_mount_subdir = 'mmgen_autosign'
  354. macOS_ramdisk_name = 'AutosignRamDisk'
  355. wallet_subdir = 'autosign'
  356. linux_blkid_cmd = '/sbin/blkid -s LABEL -o value'
  357. cmds = ('setup', 'xmr_setup', 'sign', 'wait')
  358. util_cmds = (
  359. 'gen_key',
  360. 'macos_ramdisk_setup',
  361. 'macos_ramdisk_delete',
  362. 'enable_swap',
  363. 'disable_swap',
  364. 'clean',
  365. 'wipe_key')
  366. mn_fmts = {
  367. 'mmgen': 'words',
  368. 'bip39': 'bip39',
  369. }
  370. dfl_mn_fmt = 'mmgen'
  371. non_xmr_dirs = {
  372. 'tx_dir': 'tx',
  373. 'txauto_dir': 'txauto',
  374. 'msg_dir': 'msg',
  375. }
  376. xmr_dirs = {
  377. 'xmr_dir': 'xmr',
  378. 'xmr_tx_dir': 'xmr/tx',
  379. 'xmr_outputs_dir': 'xmr/outputs',
  380. }
  381. have_xmr = False
  382. xmr_only = False
  383. def init_fixup(self): # see test/overlay/fakemods/mmgen/autosign.py
  384. pass
  385. def __init__(self,cfg,cmd=None):
  386. if cfg.mnemonic_fmt:
  387. if cfg.mnemonic_fmt not in self.mn_fmts:
  388. die(1,'{!r}: invalid mnemonic format (must be one of: {})'.format(
  389. cfg.mnemonic_fmt,
  390. fmt_list( self.mn_fmts, fmt='no_spc' ) ))
  391. if sys.platform == 'linux':
  392. self.dfl_mountpoint = f'/mnt/{self.linux_mount_subdir}'
  393. self.dfl_shm_dir = '/dev/shm'
  394. # linux-only attrs:
  395. self.old_dfl_mountpoint = '/mnt/tx'
  396. self.old_dfl_mountpoint_errmsg = f"""
  397. Mountpoint ‘{self.old_dfl_mountpoint}’ is no longer supported!
  398. Please rename ‘{self.old_dfl_mountpoint}’ to ‘{self.dfl_mountpoint}’
  399. and update your fstab accordingly.
  400. """
  401. self.mountpoint_errmsg_fs = """
  402. Mountpoint ‘{}’ does not exist or does not point
  403. to a directory! Please create the mountpoint and add an entry
  404. to your fstab as described in this script’s help text.
  405. """
  406. elif sys.platform == 'darwin':
  407. self.dfl_mountpoint = f'/Volumes/{self.dev_label}'
  408. self.dfl_shm_dir = f'/Volumes/{self.macOS_ramdisk_name}'
  409. self.cfg = cfg
  410. self.dfl_wallet_dir = f'{self.dfl_shm_dir}/{self.wallet_subdir}'
  411. self.mountpoint = Path(cfg.mountpoint or self.dfl_mountpoint)
  412. self.shm_dir = Path(self.dfl_shm_dir)
  413. self.wallet_dir = Path(cfg.wallet_dir or self.dfl_wallet_dir)
  414. if sys.platform == 'linux':
  415. self.mount_cmd = f'mount {self.mountpoint}'
  416. self.umount_cmd = f'umount {self.mountpoint}'
  417. elif sys.platform == 'darwin':
  418. self.mount_cmd = f'diskutil mount {self.dev_label}'
  419. self.umount_cmd = f'diskutil eject {self.dev_label}'
  420. self.init_fixup()
  421. if sys.platform == 'darwin': # test suite uses ‘fixed-up’ shm_dir
  422. from .platform.darwin.util import MacOSRamDisk
  423. self.ramdisk = MacOSRamDisk(
  424. cfg,
  425. self.macOS_ramdisk_name,
  426. self._get_macOS_ramdisk_size(),
  427. path = self.shm_dir)
  428. self.keyfile = self.mountpoint / 'autosign.key'
  429. if any(k in cfg._uopts for k in ('help','longhelp')):
  430. return
  431. if 'coin' in cfg._uopts:
  432. die(1,'--coin option not supported with this command. Use --coins instead')
  433. self.coins = cfg.coins.upper().split(',') if cfg.coins else []
  434. if cfg.xmrwallets and not 'XMR' in self.coins:
  435. self.coins.append('XMR')
  436. if not self.coins and cmd in self.cmds:
  437. ymsg('Warning: no coins specified, defaulting to BTC')
  438. self.coins = ['BTC']
  439. if 'XMR' in self.coins:
  440. self.have_xmr = True
  441. if len(self.coins) == 1:
  442. self.xmr_only = True
  443. self.xmr_cur_wallet_idx = None
  444. self.dirs = {}
  445. self.signables = ()
  446. if not self.xmr_only:
  447. self.dirs |= self.non_xmr_dirs
  448. self.signables += Signable.non_xmr_signables
  449. if self.have_xmr:
  450. self.dirs |= self.xmr_dirs
  451. self.signables += Signable.xmr_signables
  452. for name,path in self.dirs.items():
  453. setattr(self, name, self.mountpoint / path)
  454. self.swap = SwapMgr(self.cfg, ignore_zram=True)
  455. async def check_daemons_running(self):
  456. from .protocol import init_proto
  457. for coin in self.coins:
  458. proto = init_proto(self.cfg, coin, network=self.cfg.network, need_amt=True)
  459. if proto.sign_mode == 'daemon':
  460. self.cfg._util.vmsg(f'Checking {coin} daemon')
  461. from .rpc import rpc_init
  462. from .exception import SocketError
  463. try:
  464. await rpc_init( self.cfg, proto, ignore_wallet=True )
  465. except SocketError as e:
  466. from .daemon import CoinDaemon
  467. d = CoinDaemon( self.cfg, proto=proto, test_suite=self.cfg.test_suite )
  468. die(2,
  469. f'\n{e}\nIs the {d.coind_name} daemon ({d.exec_fn}) running '
  470. + 'and listening on the correct port?' )
  471. @property
  472. def wallet_files(self):
  473. if not hasattr(self,'_wallet_files'):
  474. try:
  475. dirlist = self.wallet_dir.iterdir()
  476. except:
  477. die(1,f"Cannot open wallet directory '{self.wallet_dir}'. Did you run ‘mmgen-autosign setup’?")
  478. self._wallet_files = [f for f in dirlist if f.suffix == '.mmdat']
  479. if not self._wallet_files:
  480. die(1,'No wallet files present!')
  481. return self._wallet_files
  482. def do_mount(self, silent=False, verbose=False):
  483. def check_or_create(dirname):
  484. path = getattr(self, dirname)
  485. if path.is_dir():
  486. if not path.stat().st_mode & S_IWUSR|S_IRUSR == S_IWUSR|S_IRUSR:
  487. die(1, f'‘{path}’ is not read/write for this user!')
  488. elif path.exists():
  489. die(1, f'‘{path}’ is not a directory!')
  490. elif path.is_symlink():
  491. die(1, f'‘{path}’ is a symlink not pointing to a directory!')
  492. else:
  493. msg(f'Creating ‘{path}’')
  494. path.mkdir(parents=True)
  495. if sys.platform == 'linux' and not self.mountpoint.is_dir():
  496. def do_die(m):
  497. die(1,'\n' + yellow(fmt(m.strip(),indent=' ')))
  498. if Path(self.old_dfl_mountpoint).is_dir():
  499. do_die(self.old_dfl_mountpoint_errmsg)
  500. else:
  501. do_die(self.mountpoint_errmsg_fs.format(self.mountpoint))
  502. if not self.mountpoint.is_mount():
  503. redir = None if verbose else DEVNULL
  504. if run(self.mount_cmd.split(), stderr=redir, stdout=redir).returncode == 0:
  505. if not silent:
  506. msg(f"Mounting '{self.mountpoint}'")
  507. else:
  508. die(1,f'Unable to mount device {self.dev_label} at {self.mountpoint}')
  509. for dirname in self.dirs:
  510. check_or_create(dirname)
  511. def do_umount(self, silent=False, verbose=False):
  512. if self.mountpoint.is_mount():
  513. run( ['sync'], check=True )
  514. if not silent:
  515. msg(f"Unmounting '{self.mountpoint}'")
  516. redir = None if verbose else DEVNULL
  517. run(self.umount_cmd.split(), stdout=redir, check=True)
  518. if not silent:
  519. bmsg('It is now safe to extract the removable device')
  520. def decrypt_wallets(self):
  521. msg(f"Unlocking wallet{suf(self.wallet_files)} with key from ‘{self.keyfile}’")
  522. fails = 0
  523. for wf in self.wallet_files:
  524. try:
  525. Wallet(self.cfg, wf, ignore_in_fmt=True, passwd_file=str(self.keyfile))
  526. except SystemExit as e:
  527. if e.code != 0:
  528. fails += 1
  529. return not fails
  530. async def sign_all(self,target_name):
  531. target = getattr(Signable,target_name)(self)
  532. if target.unsigned:
  533. good = []
  534. bad = []
  535. if len(target.unsigned) > 1 and not target.multiple_ok:
  536. ymsg(f'Autosign error: only one unsigned {target.desc} transaction allowed at a time!')
  537. target.print_bad_list(target.unsigned)
  538. return False
  539. for f in target.unsigned:
  540. ret = None
  541. try:
  542. ret = await target.sign(f)
  543. except Exception as e:
  544. ymsg(f"An error occurred with {target.desc} '{f.name}':\n {type(e).__name__}: {e!s}")
  545. except:
  546. ymsg(f"An error occurred with {target.desc} '{f.name}'")
  547. good.append(ret) if ret else bad.append(f)
  548. self.cfg._util.qmsg('')
  549. await asyncio.sleep(0.3)
  550. msg(brown(f'{len(good)} {target.desc}{suf(good)} {target.action_desc}'))
  551. if bad:
  552. rmsg(f'{len(bad)} {target.desc}{suf(bad)} {target.fail_msg}')
  553. if good and not self.cfg.no_summary:
  554. target.print_summary(good)
  555. if bad:
  556. target.print_bad_list(bad)
  557. return not bad
  558. else:
  559. return f'No unsigned {target.desc}s'
  560. async def do_sign(self):
  561. if not self.cfg.stealth_led:
  562. self.led.set('busy')
  563. self.do_mount()
  564. key_ok = self.decrypt_wallets()
  565. if key_ok:
  566. if self.cfg.stealth_led:
  567. self.led.set('busy')
  568. ret = [await self.sign_all(signable) for signable in self.signables]
  569. for val in ret:
  570. if isinstance(val,str):
  571. msg(val)
  572. if self.cfg.test_suite_autosign_threaded:
  573. await asyncio.sleep(0.3)
  574. self.do_umount()
  575. self.led.set('error' if not all(ret) else 'off' if self.cfg.stealth_led else 'standby')
  576. return all(ret)
  577. else:
  578. msg('Password is incorrect!')
  579. self.do_umount()
  580. if not self.cfg.stealth_led:
  581. self.led.set('error')
  582. return False
  583. def wipe_encryption_key(self):
  584. if self.keyfile.exists():
  585. from .fileutil import shred_file
  586. ymsg(f'Shredding wallet encryption key ‘{self.keyfile}’')
  587. shred_file(self.keyfile, verbose=self.cfg.verbose)
  588. else:
  589. gmsg('No wallet encryption key on removable device')
  590. def create_key(self):
  591. desc = f"key file '{self.keyfile}'"
  592. msg('Creating ' + desc)
  593. try:
  594. self.keyfile.write_text( os.urandom(32).hex() )
  595. self.keyfile.chmod(0o400)
  596. except:
  597. die(2,'Unable to write ' + desc)
  598. msg('Wrote ' + desc)
  599. def gen_key(self,no_unmount=False):
  600. if not self.device_inserted:
  601. die(1,'Removable device not present!')
  602. self.do_mount()
  603. self.wipe_encryption_key()
  604. self.create_key()
  605. if not no_unmount:
  606. self.do_umount()
  607. def macos_ramdisk_setup(self):
  608. self.ramdisk.create()
  609. def macos_ramdisk_delete(self):
  610. self.ramdisk.destroy()
  611. def _get_macOS_ramdisk_size(self):
  612. from .platform.darwin.util import MacOSRamDisk, warn_ramdisk_too_small
  613. # allow 1MB for each Monero wallet
  614. xmr_size = len(AddrIdxList(self.cfg.xmrwallets)) if self.cfg.xmrwallets else 0
  615. calc_size = xmr_size + 1
  616. usr_size = self.cfg.macos_ramdisk_size or self.cfg.macos_autosign_ramdisk_size
  617. if is_int(usr_size):
  618. usr_size = int(usr_size)
  619. else:
  620. die(1, f'{usr_size}: invalid user-specified macOS ramdisk size (not an integer)')
  621. min_size = MacOSRamDisk.min_size
  622. size = max(usr_size, calc_size, min_size)
  623. if usr_size and usr_size < min_size:
  624. warn_ramdisk_too_small(usr_size, min_size)
  625. return size
  626. def setup(self):
  627. def remove_wallet_dir():
  628. msg(f"Deleting '{self.wallet_dir}'")
  629. import shutil
  630. try:
  631. shutil.rmtree(self.wallet_dir)
  632. except:
  633. pass
  634. def create_wallet_dir():
  635. try:
  636. self.wallet_dir.mkdir(parents=True)
  637. except:
  638. pass
  639. try:
  640. self.wallet_dir.stat()
  641. except:
  642. die(2,f"Unable to create wallet directory '{self.wallet_dir}'")
  643. self.gen_key(no_unmount=True)
  644. self.swap.disable()
  645. if sys.platform == 'darwin':
  646. self.macos_ramdisk_setup()
  647. remove_wallet_dir()
  648. create_wallet_dir()
  649. wf = find_file_in_dir( get_wallet_cls('mmgen'), self.cfg.data_dir )
  650. if wf and keypress_confirm(
  651. cfg = self.cfg,
  652. prompt = f"Default wallet '{wf}' found.\nUse default wallet for autosigning?",
  653. default_yes = True ):
  654. ss_in = Wallet( Config(), wf )
  655. else:
  656. ss_in = Wallet( self.cfg, in_fmt=self.mn_fmts[self.cfg.mnemonic_fmt or self.dfl_mn_fmt] )
  657. ss_out = Wallet( self.cfg, ss=ss_in, passwd_file=str(self.keyfile) )
  658. ss_out.write_to_file( desc='autosign wallet', outdir=self.wallet_dir )
  659. @property
  660. def xmrwallet_cfg(self):
  661. if not hasattr(self,'_xmrwallet_cfg'):
  662. self._xmrwallet_cfg = Config({
  663. '_clone': self.cfg,
  664. 'coin': 'xmr',
  665. 'wallet_rpc_user': 'autosign',
  666. 'wallet_rpc_password': 'autosign password',
  667. 'wallet_rpc_port': 23232 if self.cfg.test_suite_xmr_autosign else None,
  668. 'wallet_dir': str(self.wallet_dir),
  669. 'autosign': True,
  670. 'autosign_mountpoint': str(self.mountpoint),
  671. 'offline': True,
  672. 'passwd_file': str(self.keyfile),
  673. })
  674. return self._xmrwallet_cfg
  675. def xmr_setup(self):
  676. def create_signing_wallets():
  677. from . import xmrwallet
  678. if len(self.wallet_files) > 1:
  679. ymsg(f'Warning: more than one wallet file, using the first ({self.wallet_files[0]}) for xmrwallet generation')
  680. m = xmrwallet.op(
  681. 'create_offline',
  682. self.xmrwallet_cfg,
  683. infile = str(self.wallet_files[0]), # MMGen wallet file
  684. wallets = self.cfg.xmrwallets) # XMR wallet idxs
  685. asyncio.run(m.main())
  686. asyncio.run(m.stop_wallet_daemon())
  687. self.clean_old_files()
  688. create_signing_wallets()
  689. def clean_old_files(self):
  690. def do_shred(f):
  691. nonlocal count
  692. msg_r('.')
  693. from .fileutil import shred_file
  694. shred_file( f, verbose=self.cfg.verbose )
  695. count += 1
  696. def clean_dir(s_name):
  697. def clean_files(rawext,sigext):
  698. for f in s.dir.iterdir():
  699. if s.clean_all and (f.name.endswith(f'.{rawext}') or f.name.endswith(f'.{sigext}')):
  700. do_shred(f)
  701. elif f.name.endswith(f'.{sigext}'):
  702. raw = f.parent / ( f.name[:-len(sigext)] + rawext )
  703. if raw.is_file():
  704. do_shred(raw)
  705. s = getattr(Signable,s_name)(self)
  706. msg_r(f"Cleaning directory '{s.dir}'..")
  707. if s.dir.is_dir():
  708. clean_files( s.rawext, s.sigext )
  709. if hasattr(s,'subext'):
  710. clean_files( s.rawext, s.subext )
  711. clean_files( s.sigext, s.subext )
  712. msg('done' if s.dir.is_dir() else 'skipped (no dir)')
  713. count = 0
  714. for s_name in self.signables:
  715. clean_dir(s_name)
  716. bmsg(f'{count} file{suf(count)} shredded')
  717. @property
  718. def device_inserted(self):
  719. if self.cfg.no_insert_check:
  720. return True
  721. if sys.platform == 'linux':
  722. cp = run(self.linux_blkid_cmd.split(), stdout=PIPE, text=True)
  723. if cp.returncode not in (0, 2):
  724. die(2, f'blkid exited with error code {cp.returncode}')
  725. return self.dev_label in cp.stdout.splitlines()
  726. elif sys.platform == 'darwin':
  727. if self.cfg.test_suite_root_pfx:
  728. return self.mountpoint.exists()
  729. else:
  730. return run(['diskutil', 'info', self.dev_label], stdout=DEVNULL, stderr=DEVNULL).returncode == 0
  731. async def main_loop(self):
  732. if not self.cfg.stealth_led:
  733. self.led.set('standby')
  734. threaded = self.cfg.test_suite_autosign_threaded
  735. n = 1 if threaded else 0
  736. prev_status = False
  737. while True:
  738. status = self.device_inserted
  739. if status and not prev_status:
  740. msg('Device insertion detected')
  741. await self.do_sign()
  742. prev_status = status
  743. if not n % 10:
  744. msg_r(f"\r{' '*17}\rWaiting")
  745. await asyncio.sleep(0.2 if threaded else 1)
  746. if not threaded:
  747. msg_r('.')
  748. n += 1
  749. def at_exit(self,exit_val,message=None):
  750. if message:
  751. msg(message)
  752. self.led.stop()
  753. sys.exit(0 if self.cfg.test_suite_autosign_threaded else int(exit_val))
  754. def init_exit_handler(self):
  755. def handler(arg1,arg2):
  756. self.at_exit(1,'\nCleaning up...')
  757. import signal
  758. signal.signal( signal.SIGTERM, handler )
  759. signal.signal( signal.SIGINT, handler )
  760. def init_led(self):
  761. from .led import LEDControl
  762. self.led = LEDControl(
  763. enabled = self.cfg.led,
  764. simulate = self.cfg.test_suite_autosign_led_simulate )
  765. self.led.set('off')