1790 lines
58 KiB
Python
Executable file
1790 lines
58 KiB
Python
Executable file
#!/usr/bin/env python
|
|
|
|
# Chdir to repo root.
|
|
# Since script is not in repo root, fix sys.path so that modules are
|
|
# imported from repo, not system.
|
|
import sys,os
|
|
pn = os.path.dirname(sys.argv[0])
|
|
os.chdir(os.path.join(pn,os.pardir))
|
|
sys.path.__setitem__(0,os.path.abspath(os.curdir))
|
|
|
|
scripts = (
|
|
"addrgen", "addrimport", "keygen",
|
|
"passchg", "pywallet", "tool",
|
|
"txcreate", "txsend", "txsign",
|
|
"walletchk", "walletconv", "walletgen"
|
|
)
|
|
|
|
import mmgen.globalvars as g
|
|
import mmgen.opt as opt
|
|
from mmgen.util import *
|
|
|
|
start_mscolor()
|
|
|
|
from mmgen.test import *
|
|
|
|
tb_cmd = "scripts/traceback.py"
|
|
hincog_fn = "rand_data"
|
|
hincog_bytes = 1024*1024
|
|
hincog_offset = 98765
|
|
hincog_seedlen = 256
|
|
|
|
incog_id_fn = "incog_id"
|
|
non_mmgen_fn = "btckey"
|
|
pwfile = "passwd_file"
|
|
|
|
ref_dir = os.path.join("test","ref")
|
|
|
|
ref_wallet_brainpass = "abc"
|
|
ref_wallet_hash_preset = "1"
|
|
ref_wallet_incog_offset = 123
|
|
|
|
ref_bw_hash_preset = "1"
|
|
ref_bw_file = "wallet.mmbrain"
|
|
ref_bw_file_spc = "wallet-spaced.mmbrain"
|
|
|
|
ref_kafile_pass = "kafile password"
|
|
ref_kafile_hash_preset = "1"
|
|
|
|
ref_enc_fn = "sample-text.mmenc"
|
|
tool_enc_passwd = "Scrypt it, don't hash it!"
|
|
sample_text = \
|
|
"The Times 03/Jan/2009 Chancellor on brink of second bailout for banks\n"
|
|
|
|
cfgs = {
|
|
'1': {
|
|
'tmpdir': os.path.join("test","tmp1"),
|
|
'wpasswd': "Dorian",
|
|
'kapasswd': "Grok the blockchain",
|
|
'addr_idx_list': "12,99,5-10,5,12", # 8 addresses
|
|
'dep_generators': {
|
|
pwfile: "walletgen",
|
|
'mmdat': "walletgen",
|
|
'addrs': "addrgen",
|
|
'raw': "txcreate",
|
|
'sig': "txsign",
|
|
'mmwords': "export_mnemonic",
|
|
'mmseed': "export_seed",
|
|
'mmincog': "export_incog",
|
|
'mmincox': "export_incog_hex",
|
|
hincog_fn: "export_incog_hidden",
|
|
incog_id_fn: "export_incog_hidden",
|
|
'akeys.mmenc': "keyaddrgen"
|
|
},
|
|
},
|
|
'2': {
|
|
'tmpdir': os.path.join("test","tmp2"),
|
|
'wpasswd': "Hodling away",
|
|
'addr_idx_list': "37,45,3-6,22-23", # 8 addresses
|
|
'seed_len': 128,
|
|
'dep_generators': {
|
|
'mmdat': "walletgen2",
|
|
'addrs': "addrgen2",
|
|
'raw': "txcreate2",
|
|
'sig': "txsign2",
|
|
'mmwords': "export_mnemonic2",
|
|
},
|
|
},
|
|
'3': {
|
|
'tmpdir': os.path.join("test","tmp3"),
|
|
'wpasswd': "Major miner",
|
|
'addr_idx_list': "73,54,1022-1023,2-5", # 8 addresses
|
|
'dep_generators': {
|
|
'mmdat': "walletgen3",
|
|
'addrs': "addrgen3",
|
|
'raw': "txcreate3",
|
|
'sig': "txsign3"
|
|
},
|
|
},
|
|
'4': {
|
|
'tmpdir': os.path.join("test","tmp4"),
|
|
'wpasswd': "Hashrate rising",
|
|
'addr_idx_list': "63,1004,542-544,7-9", # 8 addresses
|
|
'seed_len': 192,
|
|
'dep_generators': {
|
|
'mmdat': "walletgen4",
|
|
'mmbrain': "walletgen4",
|
|
'addrs': "addrgen4",
|
|
'raw': "txcreate4",
|
|
'sig': "txsign4",
|
|
},
|
|
'bw_filename': "brainwallet.mmbrain",
|
|
'bw_params': "192,1",
|
|
},
|
|
'5': {
|
|
'tmpdir': os.path.join("test","tmp5"),
|
|
'wpasswd': "My changed password",
|
|
'hash_preset': '2',
|
|
'dep_generators': {
|
|
'mmdat': "passchg",
|
|
pwfile: "passchg",
|
|
},
|
|
},
|
|
'6': {
|
|
'name': "reference wallet check (128-bit)",
|
|
'seed_len': 128,
|
|
'seed_id': "FE3C6545",
|
|
'ref_bw_seed_id': "33F10310",
|
|
'addrfile_chk': "B230 7526 638F 38CB 8FDC 8B76",
|
|
'keyaddrfile_chk': "CF83 32FB 8A8B 08E2 0F00 D601",
|
|
'wpasswd': "reference password",
|
|
'ref_wallet': "FE3C6545-D782B529[128,1].mmdat",
|
|
'ic_wallet': "FE3C6545-E29303EA-5E229E30[128,1].mmincog",
|
|
'ic_wallet_hex': "FE3C6545-BC4BE3F2-32586837[128,1].mmincox",
|
|
|
|
'hic_wallet': "FE3C6545-161E495F-BEB7548E[128:1].incog-offset123",
|
|
'hic_wallet_old': "FE3C6545-161E495F-9860A85B[128:1].incog-old.offset123",
|
|
|
|
'tmpdir': os.path.join("test","tmp6"),
|
|
'kapasswd': "",
|
|
'addr_idx_list': "1010,500-501,31-33,1,33,500,1011", # 8 addresses
|
|
'dep_generators': {
|
|
'mmdat': "refwalletgen1",
|
|
pwfile: "refwalletgen1",
|
|
'addrs': "refaddrgen1",
|
|
'akeys.mmenc': "refkeyaddrgen1"
|
|
},
|
|
|
|
},
|
|
'7': {
|
|
'name': "reference wallet check (192-bit)",
|
|
'seed_len': 192,
|
|
'seed_id': "1378FC64",
|
|
'ref_bw_seed_id': "CE918388",
|
|
'addrfile_chk': "8C17 A5FA 0470 6E89 3A87 8182",
|
|
'keyaddrfile_chk': "9648 5132 B98E 3AD9 6FC3 C5AD",
|
|
'wpasswd': "reference password",
|
|
'ref_wallet': "1378FC64-6F0F9BB4[192,1].mmdat",
|
|
'ic_wallet': "1378FC64-2907DE97-F980D21F[192,1].mmincog",
|
|
'ic_wallet_hex': "1378FC64-4DCB5174-872806A7[192,1].mmincox",
|
|
|
|
'hic_wallet': "1378FC64-B55E9958-77256FC1[192:1].incog.offset123",
|
|
'hic_wallet_old': "1378FC64-B55E9958-D85FF20C[192:1].incog-old.offset123",
|
|
|
|
'tmpdir': os.path.join("test","tmp7"),
|
|
'kapasswd': "",
|
|
'addr_idx_list': "1010,500-501,31-33,1,33,500,1011", # 8 addresses
|
|
'dep_generators': {
|
|
'mmdat': "refwalletgen2",
|
|
pwfile: "refwalletgen2",
|
|
'addrs': "refaddrgen2",
|
|
'akeys.mmenc': "refkeyaddrgen2"
|
|
},
|
|
|
|
},
|
|
'8': {
|
|
'name': "reference wallet check (256-bit)",
|
|
'seed_len': 256,
|
|
'seed_id': "98831F3A",
|
|
'ref_bw_seed_id': "B48CD7FC",
|
|
'addrfile_chk': "6FEF 6FB9 7B13 5D91 854A 0BD3",
|
|
'keyaddrfile_chk': "9F2D D781 1812 8BAD C396 9DEB",
|
|
'wpasswd': "reference password",
|
|
'ref_wallet': "98831F3A-27F2BF93[256,1].mmdat",
|
|
'ref_addrfile': "98831F3A[1,31-33,500-501,1010-1011].addrs",
|
|
'ref_keyaddrfile': "98831F3A[1,31-33,500-501,1010-1011].akeys.mmenc",
|
|
'ref_addrfile_chksum': "6FEF 6FB9 7B13 5D91 854A 0BD3",
|
|
'ref_keyaddrfile_chksum': "9F2D D781 1812 8BAD C396 9DEB",
|
|
|
|
# 'ref_fake_unspent_data':"98831F3A_unspent.json",
|
|
'ref_tx_file': "tx_FFB367[1.234].raw",
|
|
'ic_wallet': "98831F3A-5482381C-18460FB1[256,1].mmincog",
|
|
'ic_wallet_hex': "98831F3A-1630A9F2-870376A9[256,1].mmincox",
|
|
|
|
'hic_wallet': "98831F3A-F59B07A0-559CEF19[256:1].incog.offset123",
|
|
'hic_wallet_old': "98831F3A-F59B07A0-848535F3[256:1].incog-old.offset123",
|
|
|
|
'tmpdir': os.path.join("test","tmp8"),
|
|
'kapasswd': "",
|
|
'addr_idx_list': "1010,500-501,31-33,1,33,500,1011", # 8 addresses
|
|
'dep_generators': {
|
|
'mmdat': "refwalletgen3",
|
|
pwfile: "refwalletgen3",
|
|
'addrs': "refaddrgen3",
|
|
'akeys.mmenc': "refkeyaddrgen3"
|
|
},
|
|
},
|
|
'9': {
|
|
'tmpdir': os.path.join("test","tmp9"),
|
|
'tool_enc_infn': "tool_encrypt.in",
|
|
# 'tool_enc_ref_infn': "tool_encrypt_ref.in",
|
|
'wpasswd': "reference password",
|
|
'dep_generators': {
|
|
'tool_encrypt.in': "tool_encrypt",
|
|
'tool_encrypt.in.mmenc': "tool_encrypt",
|
|
# 'tool_encrypt_ref.in': "tool_encrypt_ref",
|
|
# 'tool_encrypt_ref.in.mmenc': "tool_encrypt_ref",
|
|
},
|
|
},
|
|
}
|
|
|
|
from copy import deepcopy
|
|
for a,b in ('6','11'),('7','12'),('8','13'):
|
|
cfgs[b] = deepcopy(cfgs[a])
|
|
cfgs[b]['tmpdir'] = os.path.join("test","tmp"+b)
|
|
|
|
from collections import OrderedDict
|
|
|
|
cmd_group = OrderedDict()
|
|
|
|
cmd_group['help'] = OrderedDict([
|
|
# test description depends
|
|
['helpscreens', (1,'help screens', [],1)],
|
|
])
|
|
|
|
cmd_group['main'] = OrderedDict([
|
|
['walletgen', (1,'wallet generation', [[[],1]],1)],
|
|
# ['walletchk', (1,'wallet check', [[["mmdat"],1]])],
|
|
['passchg', (5,'password, label and hash preset change',[[["mmdat",pwfile],1]],1)],
|
|
['walletchk_newpass',(5,'wallet check with new pw, label and hash preset',[[["mmdat",pwfile],5]],1)],
|
|
['addrgen', (1,'address generation', [[["mmdat",pwfile],1]],1)],
|
|
['addrimport', (1,'address import', [[["addrs"],1]],1)],
|
|
['txcreate', (1,'transaction creation', [[["addrs"],1]],1)],
|
|
['txsign', (1,'transaction signing', [[["mmdat","raw",pwfile],1]],1)],
|
|
['txsend', (1,'transaction sending', [[["sig"],1]])],
|
|
|
|
['export_seed', (1,'seed export to mmseed format', [[["mmdat"],1]])],
|
|
['export_mnemonic', (1,'seed export to mmwords format', [[["mmdat"],1]])],
|
|
['export_incog', (1,'seed export to mmincog format', [[["mmdat"],1]])],
|
|
['export_incog_hex',(1,'seed export to mmincog hex format', [[["mmdat"],1]])],
|
|
['export_incog_hidden',(1,'seed export to hidden mmincog format', [[["mmdat"],1]])],
|
|
|
|
['addrgen_seed', (1,'address generation from mmseed file', [[["mmseed","addrs"],1]])],
|
|
['addrgen_mnemonic',(1,'address generation from mmwords file',[[["mmwords","addrs"],1]])],
|
|
['addrgen_incog', (1,'address generation from mmincog file',[[["mmincog","addrs"],1]])],
|
|
['addrgen_incog_hex',(1,'address generation from mmincog hex file',[[["mmincox","addrs"],1]])],
|
|
['addrgen_incog_hidden',(1,'address generation from hidden mmincog file', [[[hincog_fn,"addrs"],1]])],
|
|
|
|
['keyaddrgen', (1,'key-address file generation', [[["mmdat",pwfile],1]])],
|
|
['txsign_keyaddr',(1,'transaction signing with key-address file', [[["akeys.mmenc","raw"],1]])],
|
|
|
|
['walletgen2',(2,'wallet generation (2), 128-bit seed', [])],
|
|
['addrgen2', (2,'address generation (2)', [[["mmdat"],2]])],
|
|
['txcreate2', (2,'transaction creation (2)', [[["addrs"],2]])],
|
|
['txsign2', (2,'transaction signing, two transactions',[[["mmdat","raw"],1],[["mmdat","raw"],2]])],
|
|
['export_mnemonic2', (2,'seed export to mmwords format (2)',[[["mmdat"],2]])],
|
|
|
|
['walletgen3',(3,'wallet generation (3)', [])],
|
|
['addrgen3', (3,'address generation (3)', [[["mmdat"],3]])],
|
|
['txcreate3', (3,'tx creation with inputs and outputs from two wallets', [[["addrs"],1],[["addrs"],3]])],
|
|
['txsign3', (3,'tx signing with inputs and outputs from two wallets',[[["mmdat"],1],[["mmdat","raw"],3]])],
|
|
|
|
['walletgen4',(4,'wallet generation (4) (brainwallet)', [])],
|
|
['addrgen4', (4,'address generation (4)', [[["mmdat"],4]])],
|
|
['txcreate4', (4,'tx creation with inputs and outputs from four seed sources, plus non-MMGen inputs and outputs', [[["addrs"],1],[["addrs"],2],[["addrs"],3],[["addrs"],4]])],
|
|
['txsign4', (4,'tx signing with inputs and outputs from incog file, mnemonic file, wallet and brainwallet, plus non-MMGen inputs and outputs', [[["mmincog"],1],[["mmwords"],2],[["mmdat"],3],[["mmbrain","raw"],4]])],
|
|
])
|
|
|
|
cmd_group['tool'] = OrderedDict([
|
|
['tool_encrypt', (9,"'mmgen-tool encrypt' (random data)", [],1)],
|
|
['tool_decrypt', (9,"'mmgen-tool decrypt' (random data)", [[[cfgs['9']['tool_enc_infn'],cfgs['9']['tool_enc_infn']+".mmenc"],9]],1)],
|
|
# ['tool_encrypt_ref', (9,"'mmgen-tool encrypt' (reference text)", [])],
|
|
['tool_find_incog_data', (9,"'mmgen-tool find_incog_data'", [[[hincog_fn],1],[[incog_id_fn],1]])],
|
|
['pywallet', (9,"'mmgen-pywallet'", [],1)],
|
|
])
|
|
|
|
# saved reference data
|
|
cmd_group['ref'] = (
|
|
# reading
|
|
('ref_wallet_chk', ([],'saved reference wallet')),
|
|
('ref_seed_chk', ([],'saved seed file')),
|
|
('ref_mn_chk', ([],'saved mnemonic file')),
|
|
('ref_hincog_chk', ([],'saved hidden incog reference wallet')),
|
|
('ref_brain_chk', ([],'saved brainwallet')),
|
|
# generating new reference ('abc' brainwallet) files:
|
|
('refwalletgen', ([],'gen new refwallet')),
|
|
('refaddrgen', (["mmdat",pwfile],'new refwallet addr chksum')),
|
|
('refkeyaddrgen', (["mmdat",pwfile],'new refwallet key-addr chksum'))
|
|
)
|
|
|
|
# misc. saved reference data
|
|
cmd_group['ref_other'] = (
|
|
('ref_addrfile_chk', 'saved reference address file'),
|
|
('ref_keyaddrfile_chk','saved reference key-address file'),
|
|
# Create the fake inputs:
|
|
# ('txcreate8', 'transaction creation (8)'),
|
|
('ref_tx_chk', 'saved reference tx file'),
|
|
('ref_brain_chk_spc3', 'saved brainwallet (non-standard spacing)'),
|
|
('ref_tool_decrypt', 'decryption of saved MMGen-encrypted file'),
|
|
)
|
|
|
|
# mmgen-walletconv:
|
|
cmd_group['conv_in'] = ( # reading
|
|
('ref_wallet_conv', 'conversion of saved reference wallet'),
|
|
('ref_mn_conv', 'conversion of saved mnemonic'),
|
|
('ref_seed_conv', 'conversion of saved seed file'),
|
|
('ref_brain_conv', 'conversion of ref brainwallet'),
|
|
('ref_incog_conv', 'conversion of saved incog wallet'),
|
|
('ref_incox_conv', 'conversion of saved hex incog wallet'),
|
|
('ref_hincog_conv', 'conversion of saved hidden incog wallet'),
|
|
('ref_hincog_conv_old','conversion of saved hidden incog wallet (old format)')
|
|
)
|
|
|
|
cmd_group['conv_out'] = ( # writing
|
|
('ref_wallet_conv_out', 'ref seed conversion to wallet'),
|
|
('ref_mn_conv_out', 'ref seed conversion to mnemonic'),
|
|
('ref_seed_conv_out', 'ref seed conversion to seed'),
|
|
('ref_incog_conv_out', 'ref seed conversion to incog data'),
|
|
('ref_incox_conv_out', 'ref seed conversion to hex incog data'),
|
|
('ref_hincog_conv_out', 'ref seed conversion to hidden incog data')
|
|
)
|
|
|
|
cmd_list = OrderedDict()
|
|
for k in cmd_group: cmd_list[k] = []
|
|
|
|
cmd_data = OrderedDict()
|
|
for k,v in (
|
|
('help', ("help screens",[])),
|
|
('main', ("basic operations",[1,2,3,4,5])),
|
|
('tool', ("tools",[9]))
|
|
):
|
|
cmd_data['info_'+k] = v
|
|
for i in cmd_group[k]:
|
|
cmd_list[k].append(i)
|
|
cmd_data[i] = cmd_group[k][i]
|
|
|
|
cmd_data['info_ref'] = "reference data",[6,7,8]
|
|
for a,b in cmd_group['ref']:
|
|
for i,j in (1,128),(2,192),(3,256):
|
|
k = a+str(i)
|
|
cmd_list['ref'].append(k)
|
|
cmd_data[k] = (5+i,"%s (%s-bit)" % (b[1],j),[[b[0],5+i]],1)
|
|
|
|
cmd_data['info_ref_other'] = "other reference data",[8]
|
|
for a,b in cmd_group['ref_other']:
|
|
cmd_list['ref_other'].append(a)
|
|
cmd_data[a] = (8,b,[[[],8]],1)
|
|
|
|
cmd_data['info_conv_in'] = "wallet conversion from reference data",[11,12,13]
|
|
for a,b in cmd_group['conv_in']:
|
|
for i,j in (1,128),(2,192),(3,256):
|
|
k = a+str(i)
|
|
cmd_list['conv_in'].append(k)
|
|
cmd_data[k] = (10+i,"%s (%s-bit)" % (b,j),[[[],10+i]],1)
|
|
|
|
cmd_data['info_conv_out'] = "wallet conversion to reference data",[11,12,13]
|
|
for a,b in cmd_group['conv_out']:
|
|
for i,j in (1,128),(2,192),(3,256):
|
|
k = a+str(i)
|
|
cmd_list['conv_out'].append(k)
|
|
cmd_data[k] = (10+i,"%s (%s-bit)" % (b,j),[[[],10+i]],1)
|
|
|
|
utils = {
|
|
'check_deps': 'check dependencies for specified command',
|
|
'clean': 'clean specified tmp dir(s) 1,2,3,4,5 or 6 (no arg = all dirs)',
|
|
}
|
|
|
|
addrs_per_wallet = 8
|
|
|
|
# total of two outputs must be < 10 BTC
|
|
for k in cfgs:
|
|
cfgs[k]['amts'] = [0,0]
|
|
for idx,mod in (0,6),(1,4):
|
|
cfgs[k]['amts'][idx] = "%s.%s" % ((getrandnum(2) % mod), str(getrandnum(4))[:5])
|
|
|
|
meta_cmds = OrderedDict([
|
|
['ref1', ("refwalletgen1","refaddrgen1","refkeyaddrgen1")],
|
|
['ref2', ("refwalletgen2","refaddrgen2","refkeyaddrgen2")],
|
|
['ref3', ("refwalletgen3","refaddrgen3","refkeyaddrgen3")],
|
|
['gen', ("walletgen","addrgen")],
|
|
['pass', ("passchg","walletchk_newpass")],
|
|
['tx', ("addrimport","txcreate","txsign","txsend")],
|
|
['export', [k for k in cmd_data if k[:7] == "export_" and cmd_data[k][0] == 1]],
|
|
['gen_sp', [k for k in cmd_data if k[:8] == "addrgen_" and cmd_data[k][0] == 1]],
|
|
['online', ("keyaddrgen","txsign_keyaddr")],
|
|
['2', [k for k in cmd_data if cmd_data[k][0] == 2]],
|
|
['3', [k for k in cmd_data if cmd_data[k][0] == 3]],
|
|
['4', [k for k in cmd_data if cmd_data[k][0] == 4]],
|
|
|
|
['saved_ref1', [c[0]+"1" for c in cmd_group['ref']]],
|
|
['saved_ref2', [c[0]+"2" for c in cmd_group['ref']]],
|
|
['saved_ref3', [c[0]+"3" for c in cmd_group['ref']]],
|
|
|
|
['saved_ref_other', [c[0] for c in cmd_group['ref_other']]],
|
|
|
|
['saved_ref_conv_in1', [c[0]+"1" for c in cmd_group['conv_in']]],
|
|
['saved_ref_conv_in2', [c[0]+"2" for c in cmd_group['conv_in']]],
|
|
['saved_ref_conv_in3', [c[0]+"3" for c in cmd_group['conv_in']]],
|
|
|
|
['saved_ref_conv_out1', [c[0]+"1" for c in cmd_group['conv_out']]],
|
|
['saved_ref_conv_out2', [c[0]+"2" for c in cmd_group['conv_out']]],
|
|
['saved_ref_conv_out3', [c[0]+"3" for c in cmd_group['conv_out']]],
|
|
])
|
|
|
|
del cmd_group
|
|
|
|
opts_data = {
|
|
# 'sets': [('non_interactive',bool,'verbose',None)],
|
|
'desc': "Test suite for the MMGen suite",
|
|
'usage':"[options] [command(s) or metacommand(s)]",
|
|
'options': """
|
|
-h, --help Print this help message.
|
|
-b, --buf-keypress Use buffered keypresses as with real human input.
|
|
-d, --debug-scripts Turn on debugging output in executed scripts.
|
|
-D, --direct-exec Bypass pexpect and execute a command directly (for
|
|
debugging only).
|
|
-e, --exact-output Show the exact output of the MMGen script(s) being run.
|
|
-l, --list-cmds List and describe the commands in the test suite.
|
|
-n, --names Display command names instead of descriptions.
|
|
-I, --non-interactive Non-interactive operation (MS Windows mode)
|
|
-p, --pause Pause between tests, resuming on keypress.
|
|
-q, --quiet Produce minimal output. Suppress dependency info.
|
|
-s, --system Test scripts and modules installed on system rather
|
|
than those in the repo root.
|
|
-t, --traceback Run the command inside the '{tb_cmd}' script.
|
|
-v, --verbose Produce more verbose output.
|
|
""".format(tb_cmd=tb_cmd),
|
|
'notes': """
|
|
|
|
If no command is given, the whole suite of tests is run.
|
|
"""
|
|
}
|
|
|
|
cmd_args = opt.opts.init(opts_data)
|
|
|
|
if opt.system: sys.path.pop(0)
|
|
ni = bool(opt.non_interactive)
|
|
|
|
# Disable MS color in spawned scripts due to bad interactions
|
|
os.environ["MMGEN_NOMSCOLOR"] = "1"
|
|
os.environ["MMGEN_NOLICENSE"] = "1"
|
|
|
|
if opt.debug_scripts: os.environ["MMGEN_DEBUG"] = "1"
|
|
|
|
if opt.buf_keypress:
|
|
send_delay = 0.3
|
|
else:
|
|
send_delay = 0
|
|
os.environ["MMGEN_DISABLE_HOLD_PROTECT"] = "1"
|
|
|
|
if opt.exact_output:
|
|
def msg(s): pass
|
|
vmsg = vmsg_r = msg_r = msg
|
|
else:
|
|
def msg(s): sys.stderr.write(s+"\n")
|
|
def vmsg(s):
|
|
if opt.verbose: sys.stderr.write(s+"\n")
|
|
def msg_r(s): sys.stderr.write(s)
|
|
def vmsg_r(s):
|
|
if opt.verbose: sys.stderr.write(s)
|
|
|
|
stderr_save = sys.stderr
|
|
|
|
def silence():
|
|
if not (opt.verbose or opt.exact_output):
|
|
f = ("/dev/null","stderr.out")[int(sys.platform[:3] == "win")]
|
|
sys.stderr = open(f,"a")
|
|
|
|
def end_silence():
|
|
if not (opt.verbose or opt.exact_output):
|
|
sys.stderr = stderr_save
|
|
|
|
def errmsg(s): stderr_save.write(s+"\n")
|
|
def errmsg_r(s): stderr_save.write(s)
|
|
|
|
if opt.list_cmds:
|
|
fs = " {:<{w}} - {}"
|
|
Msg(green("AVAILABLE COMMANDS:"))
|
|
w = max([len(i) for i in cmd_data])
|
|
for cmd in cmd_data:
|
|
if cmd[:5] == "info_":
|
|
m = capfirst(cmd_data[cmd][0])
|
|
msg(green(" %s:"% m))
|
|
continue
|
|
Msg(" "+fs.format(cmd,cmd_data[cmd][1],w=w))
|
|
|
|
w = max([len(i) for i in meta_cmds])
|
|
Msg(green("\nAVAILABLE METACOMMANDS:"))
|
|
for cmd in meta_cmds:
|
|
Msg(fs.format(cmd," ".join(meta_cmds[cmd]),w=w))
|
|
|
|
w = max([len(i) for i in cmd_list])
|
|
Msg(green("\nAVAILABLE COMMAND GROUPS:"))
|
|
for g in cmd_list:
|
|
Msg(fs.format(g," ".join(cmd_list[g]),w=w))
|
|
|
|
Msg(green("\nAVAILABLE UTILITIES:"))
|
|
w = max([len(i) for i in utils])
|
|
for cmd in sorted(utils):
|
|
Msg(fs.format(cmd,utils[cmd],w=w))
|
|
sys.exit()
|
|
|
|
import time,re
|
|
try:
|
|
import pexpect
|
|
except: # Windows
|
|
m = green("MS Windows detected (or missing pexpect module). Skipping some tests.\n")
|
|
n = green("Interactive mode. User prompts will be ")
|
|
p = grnbg("HIGHLIGHTED IN GREEN")
|
|
q = green(".\nContinue?")
|
|
ni = True
|
|
from mmgen.util import keypress_confirm
|
|
if not keypress_confirm(m+n+p+q,default_yes=True):
|
|
errmsg("Exiting at user request")
|
|
sys.exit()
|
|
|
|
from mmgen.util import get_data_from_file,write_data_to_file,get_lines_from_file
|
|
|
|
def my_send(p,t,delay=send_delay,s=False):
|
|
if delay: time.sleep(delay)
|
|
ret = p.send(t) # returns num bytes written
|
|
if delay: time.sleep(delay)
|
|
if opt.verbose:
|
|
ls = "" if opt.debug or not s else " "
|
|
es = "" if s else " "
|
|
msg("%sSEND %s%s" % (ls,es,yellow("'%s'"%t.replace('\n',r'\n'))))
|
|
return ret
|
|
|
|
def my_expect(p,s,t='',delay=send_delay,regex=False,nonl=False):
|
|
quo = "'" if type(s) == str else ""
|
|
|
|
if opt.verbose: msg_r("EXPECT %s" % yellow(quo+str(s)+quo))
|
|
else: msg_r("+")
|
|
|
|
try:
|
|
if s == '': ret = 0
|
|
else:
|
|
f = p.expect if regex else p.expect_exact
|
|
ret = f(s,timeout=3)
|
|
except pexpect.TIMEOUT:
|
|
errmsg(red("\nERROR. Expect %s%s%s timed out. Exiting" % (quo,s,quo)))
|
|
sys.exit(1)
|
|
|
|
if opt.debug or (opt.verbose and type(s) != str): msg_r(" ==> %s " % ret)
|
|
|
|
if ret == -1:
|
|
errmsg("Error. Expect returned %s" % ret)
|
|
sys.exit(1)
|
|
else:
|
|
if t == '':
|
|
if not nonl: vmsg("")
|
|
else:
|
|
my_send(p,t,delay,s)
|
|
return ret
|
|
|
|
def get_file_with_ext(ext,mydir,delete=True,no_dot=False):
|
|
|
|
dot = ('.','')[int(no_dot)]
|
|
flist = [os.path.join(mydir,f) for f in os.listdir(mydir)
|
|
if f == ext or f[-len(dot+ext):] == dot+ext]
|
|
|
|
if not flist: return False
|
|
|
|
if len(flist) > 1:
|
|
if delete:
|
|
if not opt.quiet:
|
|
msg("Multiple *.%s files in '%s' - deleting" % (ext,mydir))
|
|
for f in flist: os.unlink(f)
|
|
return False
|
|
else:
|
|
return flist[0]
|
|
|
|
def get_addrfile_checksum(display=False):
|
|
addrfile = get_file_with_ext("addrs",cfg['tmpdir'])
|
|
silence()
|
|
from mmgen.addr import AddrInfo
|
|
chk = AddrInfo(addrfile).checksum
|
|
if opt.verbose and display: msg("Checksum: %s" % cyan(chk))
|
|
end_silence()
|
|
return chk
|
|
|
|
def verify_checksum_or_exit(checksum,chk):
|
|
if checksum != chk:
|
|
errmsg(red("Checksum error: %s" % chk))
|
|
sys.exit(1)
|
|
vmsg(green("Checksums match: %s") % (cyan(chk)))
|
|
|
|
|
|
class MMGenExpect(object):
|
|
|
|
def __init__(self,name,mmgen_cmd,cmd_args=[],extra_desc="",no_output=False):
|
|
if not opt.system:
|
|
mmgen_cmd = os.path.join(os.curdir,mmgen_cmd)
|
|
desc = (cmd_data[name][1],name)[int(bool(opt.names))]
|
|
if extra_desc: desc += " " + extra_desc
|
|
if opt.verbose or opt.exact_output:
|
|
sys.stderr.write(
|
|
green("Testing: %s\nExecuting " % desc) +
|
|
cyan("'%s %s'\n" % (mmgen_cmd," ".join(cmd_args)))
|
|
)
|
|
else:
|
|
m = "Testing %s: " % desc
|
|
msg_r(yellow(m) if ni else m)
|
|
|
|
if opt.direct_exec or ni:
|
|
msg("")
|
|
from subprocess import call,check_output
|
|
f = (call,check_output)[int(no_output)]
|
|
ret = f(["python", mmgen_cmd] + cmd_args)
|
|
if f == call and ret != 0:
|
|
m = "Warning: process returned a non-zero exit status (%s)"
|
|
msg(red(m % ret))
|
|
else:
|
|
if opt.traceback:
|
|
cmd_args = [mmgen_cmd] + cmd_args
|
|
mmgen_cmd = tb_cmd
|
|
self.p = pexpect.spawn(mmgen_cmd,cmd_args)
|
|
if opt.exact_output: self.p.logfile = sys.stdout
|
|
|
|
def license(self):
|
|
if "MMGEN_NOLICENSE" in os.environ: return
|
|
p = "'w' for conditions and warranty info, or 'c' to continue: "
|
|
my_expect(self.p,p,'c')
|
|
|
|
def label(self,label="Test Label"):
|
|
p = "Enter a wallet label, or hit ENTER for no label: "
|
|
my_expect(self.p,p,label+"\n")
|
|
|
|
def usr_rand_out(self,saved=False):
|
|
m = "%suser-supplied entropy" % ("saved " if saved else "")
|
|
my_expect(self.p,"Generating encryption key from OS random data plus " + m)
|
|
|
|
def usr_rand(self,num_chars):
|
|
rand_chars = list(getrandstr(num_chars,no_space=True))
|
|
my_expect(self.p,'symbols left: ','x')
|
|
try:
|
|
vmsg_r("SEND ")
|
|
while self.p.expect('left: ',0.1) == 0:
|
|
ch = rand_chars.pop(0)
|
|
msg_r(yellow(ch)+" " if opt.verbose else "+")
|
|
self.p.send(ch)
|
|
except:
|
|
vmsg("EOT")
|
|
my_expect(self.p,"ENTER to continue: ",'\n')
|
|
|
|
def passphrase_new(self,desc,passphrase):
|
|
my_expect(self.p,("Enter passphrase for %s: " % desc), passphrase+"\n")
|
|
my_expect(self.p,"Repeat passphrase: ", passphrase+"\n")
|
|
|
|
def passphrase(self,desc,passphrase,pwtype=""):
|
|
if pwtype: pwtype += " "
|
|
my_expect(self.p,("Enter %spassphrase for %s.*?: " % (pwtype,desc)),
|
|
passphrase+"\n",regex=True)
|
|
|
|
def hash_preset(self,desc,preset=''):
|
|
my_expect(self.p,("Enter hash preset for %s" % desc))
|
|
my_expect(self.p,("or hit ENTER .*?:"), str(preset)+"\n",regex=True)
|
|
|
|
def written_to_file(self,desc,overwrite_unlikely=False,query="Overwrite? ",oo=False):
|
|
s1 = "%s written to file " % desc
|
|
s2 = query + "Type uppercase 'YES' to confirm: "
|
|
ret = my_expect(self.p,s1 if overwrite_unlikely else [s1,s2])
|
|
if ret == 1:
|
|
my_send(self.p,"YES\n")
|
|
# if oo:
|
|
outfile = self.expect_getend("Overwriting file '").rstrip("'")
|
|
return outfile
|
|
# else:
|
|
# ret = my_expect(self.p,s1)
|
|
outfile = self.p.readline().strip().strip("'")
|
|
vmsg("%s file: %s" % (desc,cyan(outfile.replace("'",""))))
|
|
return outfile
|
|
|
|
def no_overwrite(self):
|
|
self.expect("Overwrite? Type uppercase 'YES' to confirm: ","\n")
|
|
self.expect("Exiting at user request")
|
|
|
|
def tx_view(self):
|
|
my_expect(self.p,r"View .*?transaction.*? \(y\)es, \(N\)o, pager \(v\)iew.*?: ","\n",regex=True)
|
|
|
|
def expect_getend(self,s,regex=False):
|
|
ret = self.expect(s,regex=regex,nonl=True)
|
|
end = self.readline().strip()
|
|
vmsg(" ==> %s" % cyan(end))
|
|
return end
|
|
|
|
def interactive(self):
|
|
return self.p.interact()
|
|
|
|
def logfile(self,arg):
|
|
self.p.logfile = arg
|
|
|
|
def expect(self,*args,**kwargs):
|
|
return my_expect(self.p,*args,**kwargs)
|
|
|
|
def send(self,*args,**kwargs):
|
|
return my_send(self.p,*args,**kwargs)
|
|
|
|
def readline(self):
|
|
return self.p.readline()
|
|
|
|
def close(self):
|
|
return self.p.close()
|
|
|
|
def readlines(self):
|
|
return [l.rstrip()+"\n" for l in self.p.readlines()]
|
|
|
|
def read(self,n=None):
|
|
return self.p.read(n)
|
|
|
|
from mmgen.rpc.data import TransactionInfo
|
|
from decimal import Decimal
|
|
from mmgen.bitcoin import verify_addr
|
|
|
|
def add_fake_unspent_entry(out,address,comment):
|
|
out.append(TransactionInfo(
|
|
account = unicode(comment),
|
|
vout = int(getrandnum(4) % 8),
|
|
txid = unicode(hexlify(os.urandom(32))),
|
|
amount = Decimal("%s.%s" % (10+(getrandnum(4) % 40), getrandnum(4) % 100000000)),
|
|
address = address,
|
|
spendable = False,
|
|
scriptPubKey = ("76a914"+verify_addr(address,return_hex=True)+"88ac"),
|
|
confirmations = getrandnum(4) % 500
|
|
))
|
|
|
|
def create_fake_unspent_data(adata,unspent_data_file,tx_data,non_mmgen_input=''):
|
|
|
|
out = []
|
|
for s in tx_data:
|
|
sid = tx_data[s]['sid']
|
|
a = adata.addrinfo(sid)
|
|
for n,(idx,btcaddr) in enumerate(a.addrpairs(),1):
|
|
lbl = (""," addr %02i" % n)[int(bool(n%3))]
|
|
add_fake_unspent_entry(out,btcaddr,"%s:%s%s" % (sid,idx,lbl))
|
|
|
|
if non_mmgen_input:
|
|
from mmgen.bitcoin import privnum2addr,hextowif
|
|
privnum = getrandnum(32)
|
|
btcaddr = privnum2addr(privnum,compressed=True)
|
|
of = os.path.join(cfgs[non_mmgen_input]['tmpdir'],non_mmgen_fn)
|
|
write_data_to_file(of, hextowif("{:064x}".format(privnum),
|
|
compressed=True)+"\n","compressed bitcoin key",silent=True)
|
|
|
|
add_fake_unspent_entry(out,btcaddr,"Non-MMGen address")
|
|
|
|
# msg("\n".join([repr(o) for o in out])); sys.exit()
|
|
write_data_to_file(unspent_data_file,repr(out),"Unspent outputs",silent=True)
|
|
|
|
|
|
def add_comments_to_addr_file(addrfile,outfile):
|
|
silence()
|
|
msg(green("Adding comments to address file '%s'" % addrfile))
|
|
from mmgen.addr import AddrInfo
|
|
a = AddrInfo(addrfile)
|
|
for n,idx in enumerate(a.idxs(),1):
|
|
if n % 2: a.set_comment(idx,"Test address %s" % n)
|
|
write_data_to_file(outfile,a.fmt_data(enable_comments=True),silent=True)
|
|
end_silence()
|
|
|
|
def make_brainwallet_file(fn):
|
|
# Print random words with random whitespace in between
|
|
from mmgen.mn_tirosh import words
|
|
wl = words.split()
|
|
nwords,ws_list,max_spaces = 10," \n",5
|
|
def rand_ws_seq():
|
|
nchars = getrandnum(1) % max_spaces + 1
|
|
return "".join([ws_list[getrandnum(1)%len(ws_list)] for i in range(nchars)])
|
|
rand_pairs = [wl[getrandnum(4) % len(wl)] + rand_ws_seq() for i in range(nwords)]
|
|
d = "".join(rand_pairs).rstrip() + "\n"
|
|
if opt.verbose: msg_r("Brainwallet password:\n%s" % cyan(d))
|
|
write_data_to_file(fn,d,"brainwallet password",silent=True)
|
|
|
|
def do_between():
|
|
if opt.pause:
|
|
from mmgen.util import keypress_confirm
|
|
if keypress_confirm(green("Continue?"),default_yes=True):
|
|
if opt.verbose or opt.exact_output: sys.stderr.write("\n")
|
|
else:
|
|
errmsg("Exiting at user request")
|
|
sys.exit()
|
|
elif opt.verbose or opt.exact_output:
|
|
sys.stderr.write("\n")
|
|
|
|
|
|
rebuild_list = OrderedDict()
|
|
|
|
def check_needs_rerun(
|
|
ts,
|
|
cmd,
|
|
build=False,
|
|
root=True,
|
|
force_delete=False,
|
|
dpy=False
|
|
):
|
|
|
|
rerun = True if root else False # force_delete is not passed to recursive call
|
|
|
|
fns = []
|
|
if force_delete or not root:
|
|
# does cmd produce a needed dependency(ies)?
|
|
ret = ts.get_num_exts_for_cmd(cmd,dpy)
|
|
if ret:
|
|
for ext in ret[1]:
|
|
fn = get_file_with_ext(ext,cfgs[ret[0]]['tmpdir'],delete=build)
|
|
if fn:
|
|
if force_delete: os.unlink(fn)
|
|
else: fns.append(fn)
|
|
else: rerun = True
|
|
|
|
fdeps = ts.generate_file_deps(cmd)
|
|
cdeps = ts.generate_cmd_deps(fdeps)
|
|
|
|
for fn in fns:
|
|
my_age = os.stat(fn).st_mtime
|
|
for num,ext in fdeps:
|
|
f = get_file_with_ext(ext,cfgs[num]['tmpdir'],delete=build)
|
|
if f and os.stat(f).st_mtime > my_age: rerun = True
|
|
|
|
for cdep in cdeps:
|
|
if check_needs_rerun(ts,cdep,build=build,root=False,dpy=cmd): rerun = True
|
|
|
|
if build:
|
|
if rerun:
|
|
for fn in fns:
|
|
if not root: os.unlink(fn)
|
|
ts.do_cmd(cmd)
|
|
if not root: do_between()
|
|
else:
|
|
# If prog produces multiple files:
|
|
if cmd not in rebuild_list or rerun == True:
|
|
rebuild_list[cmd] = (rerun,fns[0] if fns else "") # FIX
|
|
|
|
return rerun
|
|
|
|
def refcheck(desc,chk,refchk):
|
|
vmsg("Comparing %s '%s' to stored reference" % (desc,chk))
|
|
if chk == refchk:
|
|
ok()
|
|
else:
|
|
if not opt.verbose: errmsg("")
|
|
errmsg(red("""
|
|
Fatal error - %s '%s' does not match reference value '%s'. Aborting test
|
|
""".strip() % (desc,chk,refchk)))
|
|
sys.exit(3)
|
|
|
|
def check_deps(cmds):
|
|
if len(cmds) != 1:
|
|
msg("Usage: %s check_deps <command>" % g.prog_name)
|
|
sys.exit(1)
|
|
|
|
cmd = cmds[0]
|
|
|
|
if cmd not in cmd_data:
|
|
msg("'%s': unrecognized command" % cmd)
|
|
sys.exit(1)
|
|
|
|
if not opt.quiet:
|
|
msg("Checking dependencies for '%s'" % (cmd))
|
|
|
|
check_needs_rerun(ts,cmd,build=False)
|
|
|
|
w = max(len(i) for i in rebuild_list) + 1
|
|
for cmd in rebuild_list:
|
|
c = rebuild_list[cmd]
|
|
m = "Rebuild" if (c[0] and c[1]) else "Build" if c[0] else "OK"
|
|
msg("cmd {:<{w}} {}".format(cmd+":", m, w=w))
|
|
# mmsg(cmd,c)
|
|
|
|
|
|
def clean(usr_dirs=[]):
|
|
all_dirs = MMGenTestSuite().list_tmp_dirs()
|
|
dirs = (usr_dirs or all_dirs)
|
|
for d in sorted(dirs):
|
|
if str(d) in all_dirs:
|
|
cleandir(all_dirs[str(d)])
|
|
else:
|
|
die(1,"%s: invalid directory number" % d)
|
|
|
|
class MMGenTestSuite(object):
|
|
|
|
def __init__(self):
|
|
pass
|
|
|
|
def list_tmp_dirs(self):
|
|
d = {}
|
|
for k in cfgs: d[k] = cfgs[k]['tmpdir']
|
|
return d
|
|
|
|
def get_num_exts_for_cmd(self,cmd,dpy=False): # dpy ignored here
|
|
num = str(cmd_data[cmd][0])
|
|
dgl = cfgs[num]['dep_generators']
|
|
# mmsg(num,cmd,dgl)
|
|
if cmd in dgl.values():
|
|
exts = [k for k in dgl if dgl[k] == cmd]
|
|
return (num,exts)
|
|
else:
|
|
return None
|
|
|
|
def do_cmd(self,cmd):
|
|
|
|
if ni and (len(cmd_data[cmd]) < 4 or cmd_data[cmd][3] != 1): return
|
|
|
|
d = [(str(num),ext) for exts,num in cmd_data[cmd][2] for ext in exts]
|
|
al = [get_file_with_ext(ext,cfgs[num]['tmpdir']) for num,ext in d]
|
|
|
|
global cfg
|
|
cfg = cfgs[str(cmd_data[cmd][0])]
|
|
|
|
self.__class__.__dict__[cmd](*([self,cmd] + al))
|
|
|
|
def generate_file_deps(self,cmd):
|
|
return [(str(n),e) for exts,n in cmd_data[cmd][2] for e in exts]
|
|
|
|
def generate_cmd_deps(self,fdeps):
|
|
return [cfgs[str(n)]['dep_generators'][ext] for n,ext in fdeps]
|
|
|
|
def helpscreens(self,name):
|
|
for s in scripts:
|
|
t = MMGenExpect(name,("mmgen-"+s),["--help"],
|
|
extra_desc="(mmgen-%s)"%s,no_output=True)
|
|
if not ni:
|
|
t.read(); ok()
|
|
|
|
def walletgen(self,name,seed_len=None):
|
|
write_to_tmpfile(cfg,pwfile,cfg['wpasswd']+"\n")
|
|
add_args = (["-r10"],
|
|
["-q","-r0","-L","NI Wallet","-P",get_tmpfile_fn(cfg,pwfile)])[int(ni)]
|
|
args = ["-d",cfg['tmpdir'],"-p1"]
|
|
if seed_len: args += ["-l",str(seed_len)]
|
|
t = MMGenExpect(name,"mmgen-walletgen", args + add_args)
|
|
if ni: return
|
|
t.license()
|
|
t.usr_rand(10)
|
|
t.passphrase_new("new MMGen wallet",cfg['wpasswd'])
|
|
t.label()
|
|
t.written_to_file("MMGen wallet")
|
|
ok()
|
|
|
|
def brainwalletgen_ref(self,name):
|
|
sl_arg = "-l%s" % cfg['seed_len']
|
|
hp_arg = "-p%s" % ref_wallet_hash_preset
|
|
label = "test.py ref. wallet (pw '%s', seed len %s)" \
|
|
% (ref_wallet_brainpass,cfg['seed_len'])
|
|
bf = "ref.mmbrain"
|
|
args = ["-d",cfg['tmpdir'],hp_arg,sl_arg,"-ib","-L",label]
|
|
write_to_tmpfile(cfg,bf,ref_wallet_brainpass)
|
|
write_to_tmpfile(cfg,pwfile,cfg['wpasswd'])
|
|
if ni:
|
|
add_args = ["-r0", "-q", "-P%s" % get_tmpfile_fn(cfg,pwfile),
|
|
get_tmpfile_fn(cfg,bf)]
|
|
else:
|
|
add_args = ["-r10"]
|
|
t = MMGenExpect(name,"mmgen-walletconv", args + add_args)
|
|
if ni: return
|
|
t.license()
|
|
t.expect("Enter brainwallet: ", ref_wallet_brainpass+"\n")
|
|
t.passphrase_new("new MMGen wallet",cfg['wpasswd'])
|
|
t.usr_rand(10)
|
|
sid = t.written_to_file("MMGen wallet").split("-")[0].split("/")[-1]
|
|
refcheck("Seed ID",sid,cfg['seed_id'])
|
|
|
|
def refwalletgen(self,name): self.brainwalletgen_ref(name)
|
|
|
|
def passchg(self,name,wf,pf):
|
|
# ni: reuse password, since there's no way to change it non-interactively
|
|
silence()
|
|
write_to_tmpfile(cfg,pwfile,get_data_from_file(pf))
|
|
end_silence()
|
|
add_args = (["-r16"],["-q","-r0","-P",pf])[int(ni)]
|
|
t = MMGenExpect(name,"mmgen-passchg", add_args +
|
|
["-d",cfg['tmpdir'],"-p","2","-L","New Label",wf])
|
|
if ni: return
|
|
t.license()
|
|
t.passphrase("MMGen wallet",cfgs['1']['wpasswd'],pwtype="old")
|
|
t.expect_getend("Hash preset changed to ")
|
|
t.passphrase("MMGen wallet",cfg['wpasswd'],pwtype="new")
|
|
t.expect("Repeat passphrase: ",cfg['wpasswd']+"\n")
|
|
t.usr_rand(16)
|
|
t.expect_getend("Label changed to ")
|
|
# t.expect_getend("Key ID changed: ")
|
|
t.written_to_file("MMGen wallet")
|
|
ok()
|
|
|
|
def walletchk(self,name,wf,pf,desc="MMGen wallet",
|
|
add_args=[],sid=None,pw=False,extra_desc=""):
|
|
args = ["-P",pf,"-q"] if ni and pf else []
|
|
hp = cfg['hash_preset'] if 'hash_preset' in cfg else '1'
|
|
wf_arg = [wf] if wf else []
|
|
t = MMGenExpect(name,"mmgen-walletchk",
|
|
add_args+args+["-p",hp]+wf_arg,
|
|
extra_desc=extra_desc)
|
|
if ni:
|
|
if sid:
|
|
n = "" if desc == "MMGen wallet" else " should be"
|
|
m = grnbg("Seed ID%s:" % n)
|
|
msg(grnbg("%s %s" % (m,cyan(sid))))
|
|
return
|
|
if desc != "hidden incognito data":
|
|
t.expect("Getting %s from file '%s'" % (desc,wf))
|
|
if pw:
|
|
t.passphrase(desc,cfg['wpasswd'])
|
|
t.expect(
|
|
["Passphrase is OK", "Passphrase.* are correct"],
|
|
regex=True
|
|
)
|
|
chk = t.expect_getend("Valid %s for Seed ID " % desc)[:8]
|
|
if sid: cmp_or_die(chk,sid)
|
|
else: ok()
|
|
|
|
def walletchk_newpass (self,name,wf,pf):
|
|
return self.walletchk(name,wf,pf,pw=True)
|
|
|
|
def addrgen(self,name,wf,pf,check_ref=False):
|
|
add_args = ["-P",pf,"-q"] if ni else []
|
|
t = MMGenExpect(name,"mmgen-addrgen", add_args +
|
|
["-d",cfg['tmpdir'],wf,cfg['addr_idx_list']])
|
|
if ni: return
|
|
t.license()
|
|
t.passphrase("MMGen wallet",cfg['wpasswd'])
|
|
t.expect("Passphrase is OK")
|
|
chk = t.expect_getend(r"Checksum for address data .*?: ",regex=True)
|
|
if check_ref:
|
|
refcheck("address data checksum",chk,cfg['addrfile_chk'])
|
|
return
|
|
t.written_to_file("Addresses",oo=True)
|
|
ok()
|
|
|
|
def refaddrgen(self,name,wf,pf):
|
|
d = " (%s-bit seed)" % cfg['seed_len']
|
|
self.addrgen(name,wf,pf=pf,check_ref=True)
|
|
|
|
def addrimport(self,name,addrfile):
|
|
add_args = ["-q","-t"] if ni else []
|
|
outfile = os.path.join(cfg['tmpdir'],"addrfile_w_comments")
|
|
add_comments_to_addr_file(addrfile,outfile)
|
|
t = MMGenExpect(name,"mmgen-addrimport", add_args + [outfile])
|
|
if ni: return
|
|
t.expect_getend(r"Checksum for address data .*\[.*\]: ",regex=True)
|
|
t.expect_getend("Validating addresses...OK. ")
|
|
t.expect("Type uppercase 'YES' to confirm: ","\n")
|
|
vmsg("This is a simulation, so no addresses were actually imported into the tracking\nwallet")
|
|
ok()
|
|
|
|
def txcreate(self,name,addrfile):
|
|
self.txcreate_common(name,sources=['1'])
|
|
|
|
def txcreate_common(self,name,sources=['1'],non_mmgen_input=''):
|
|
if opt.verbose or opt.exact_output:
|
|
sys.stderr.write(green("Generating fake transaction info\n"))
|
|
silence()
|
|
from mmgen.addr import AddrInfo,AddrInfoList
|
|
tx_data,ail = {},AddrInfoList()
|
|
from mmgen.util import parse_addr_idxs
|
|
for s in sources:
|
|
afile = get_file_with_ext("addrs",cfgs[s]["tmpdir"])
|
|
ai = AddrInfo(afile)
|
|
ail.add(ai)
|
|
aix = parse_addr_idxs(cfgs[s]['addr_idx_list'])
|
|
if len(aix) != addrs_per_wallet:
|
|
errmsg(red("Address index list length != %s: %s" %
|
|
(addrs_per_wallet,repr(aix))))
|
|
sys.exit()
|
|
tx_data[s] = {
|
|
'addrfile': afile,
|
|
'chk': ai.checksum,
|
|
'sid': ai.seed_id,
|
|
'addr_idxs': aix[-2:],
|
|
}
|
|
|
|
unspent_data_file = os.path.join(cfg['tmpdir'],"unspent.json")
|
|
create_fake_unspent_data(ail,unspent_data_file,tx_data,non_mmgen_input)
|
|
|
|
# make the command line
|
|
from mmgen.bitcoin import privnum2addr
|
|
btcaddr = privnum2addr(getrandnum(32),compressed=True)
|
|
|
|
cmd_args = ["-d",cfg['tmpdir']]
|
|
for num in tx_data:
|
|
s = tx_data[num]
|
|
cmd_args += [
|
|
"%s:%s,%s" % (s['sid'],s['addr_idxs'][0],cfgs[num]['amts'][0]),
|
|
]
|
|
# + one BTC address
|
|
# + one change address and one BTC address
|
|
if num is tx_data.keys()[-1]:
|
|
cmd_args += ["%s:%s" % (s['sid'],s['addr_idxs'][1])]
|
|
cmd_args += ["%s,%s" % (btcaddr,cfgs[num]['amts'][1])]
|
|
|
|
for num in tx_data: cmd_args += [tx_data[num]['addrfile']]
|
|
|
|
os.environ["MMGEN_BOGUS_WALLET_DATA"] = unspent_data_file
|
|
end_silence()
|
|
if opt.verbose or opt.exact_output: sys.stderr.write("\n")
|
|
|
|
add_args = ["-q"] if ni else []
|
|
if ni:
|
|
m = "\nAnswer the interactive prompts as follows:\n" + \
|
|
" 'y', 'y', 'q', '1-8'<ENTER>, ENTER, ENTER, ENTER, 'y'"
|
|
msg(grnbg(m))
|
|
t = MMGenExpect(name,"mmgen-txcreate",add_args + cmd_args)
|
|
if ni: return
|
|
t.license()
|
|
for num in tx_data:
|
|
t.expect_getend("Getting address data from file ")
|
|
chk=t.expect_getend(r"Checksum for address data .*?: ",regex=True)
|
|
verify_checksum_or_exit(tx_data[num]['chk'],chk)
|
|
|
|
# not in tracking wallet warning, (1 + num sources) times
|
|
if t.expect(["Continue anyway? (y/N): ",
|
|
"Unable to connect to bitcoind"]) == 0:
|
|
t.send("y")
|
|
else:
|
|
errmsg(red("Error: unable to connect to bitcoind. Exiting"))
|
|
sys.exit(1)
|
|
|
|
for num in tx_data:
|
|
t.expect("Continue anyway? (y/N): ","y")
|
|
t.expect(r"'q' = quit sorting, .*?: ","M", regex=True)
|
|
t.expect(r"'q' = quit sorting, .*?: ","q", regex=True)
|
|
outputs_list = [addrs_per_wallet*i + 1 for i in range(len(tx_data))]
|
|
if non_mmgen_input: outputs_list.append(len(tx_data)*addrs_per_wallet + 1)
|
|
t.expect("Enter a range or space-separated list of outputs to spend: ",
|
|
" ".join([str(i) for i in outputs_list])+"\n")
|
|
if non_mmgen_input: t.expect("Accept? (y/N): ","y")
|
|
t.expect("OK? (Y/n): ","y")
|
|
t.expect("Add a comment to transaction? (y/N): ","\n")
|
|
t.tx_view()
|
|
t.expect("Save transaction? (y/N): ","y")
|
|
t.written_to_file("Transaction")
|
|
ok()
|
|
|
|
def txsign_end(self,t,tnum=None):
|
|
t.expect("Signing transaction")
|
|
t.expect("Edit transaction comment? (y/N): ","\n")
|
|
t.expect("Save signed transaction? (Y/n): ","y")
|
|
add = " #" + tnum if tnum else ""
|
|
t.written_to_file("Signed transaction" + add, oo=True)
|
|
|
|
def txsign(self,name,txfile,wf,pf="",save=True):
|
|
add_args = ["-q","-P",pf] if ni else []
|
|
if ni:
|
|
m = "\nAnswer the interactive prompts as follows:\n ENTER, ENTER, ENTER"
|
|
msg(grnbg(m))
|
|
t = MMGenExpect(name,"mmgen-txsign", add_args +
|
|
["-d",cfg['tmpdir'],txfile,wf])
|
|
if ni: return
|
|
t.license()
|
|
t.tx_view()
|
|
t.passphrase("MMGen wallet",cfg['wpasswd'])
|
|
if save:
|
|
self.txsign_end(t)
|
|
else:
|
|
t.expect("Edit transaction comment? (y/N): ","\n")
|
|
t.close()
|
|
ok()
|
|
|
|
def txsend(self,name,sigfile):
|
|
t = MMGenExpect(name,"mmgen-txsend", ["-d",cfg['tmpdir'],sigfile])
|
|
t.license()
|
|
t.tx_view()
|
|
t.expect("Edit transaction comment? (y/N): ","\n")
|
|
t.expect("broadcast this transaction to the network?")
|
|
t.expect("'YES, I REALLY WANT TO DO THIS' to confirm: ","\n")
|
|
t.expect("Exiting at user request")
|
|
vmsg("This is a simulation; no transaction was sent")
|
|
ok()
|
|
|
|
def walletconv_export(self,name,wf,desc,uargs=[],out_fmt="w",pw=False):
|
|
opts = ["-d",cfg['tmpdir'],"-o",out_fmt] + uargs + [wf]
|
|
t = MMGenExpect(name,"mmgen-walletconv",opts)
|
|
t.license()
|
|
t.passphrase("MMGen wallet",cfg['wpasswd'])
|
|
if pw:
|
|
t.passphrase_new("new "+desc,cfg['wpasswd'])
|
|
t.usr_rand(10)
|
|
if " ".join(desc.split()[-2:]) == "incognito data":
|
|
t.expect("Generating encryption key from OS random data ")
|
|
t.expect("Generating encryption key from OS random data ")
|
|
ic_id = t.expect_getend("New Incog Wallet ID: ")
|
|
t.expect("Generating encryption key from OS random data ")
|
|
if desc == "hidden incognito data":
|
|
write_to_tmpfile(cfg,incog_id_fn,ic_id)
|
|
ret = t.expect(["Create? (Y/n): ","'YES' to confirm: "])
|
|
if ret == 0:
|
|
t.send("\n")
|
|
t.expect("Enter file size: ",str(hincog_bytes)+"\n")
|
|
else:
|
|
t.send("YES\n")
|
|
if out_fmt == "w": t.label()
|
|
return t.written_to_file(capfirst(desc),oo=True)
|
|
|
|
def export_seed(self,name,wf,desc="seed data",out_fmt="seed"):
|
|
f = self.walletconv_export(name,wf,desc=desc,out_fmt=out_fmt)
|
|
silence()
|
|
msg("%s: %s" % (capfirst(desc),cyan(get_data_from_file(f,desc))))
|
|
end_silence()
|
|
ok()
|
|
|
|
def export_mnemonic(self,name,wf):
|
|
self.export_seed(name,wf,desc="mnemonic data",out_fmt="words")
|
|
|
|
def export_incog(self,name,wf,desc="incognito data",out_fmt="i",add_args=[]):
|
|
uargs = ["-p1","-r10"] + add_args
|
|
self.walletconv_export(name,wf,desc=desc,out_fmt=out_fmt,uargs=uargs,pw=True)
|
|
ok()
|
|
|
|
def export_incog_hex(self,name,wf):
|
|
self.export_incog(name,wf,desc="hex incognito data",out_fmt="xi")
|
|
|
|
# TODO: make outdir and hidden incog compatible (ignore --outdir and warn user?)
|
|
def export_incog_hidden(self,name,wf):
|
|
rf = os.path.join(cfg['tmpdir'],hincog_fn)
|
|
add_args = ["-J","%s,%s"%(rf,hincog_offset)]
|
|
self.export_incog(
|
|
name,wf,desc="hidden incognito data",out_fmt="hi",add_args=add_args)
|
|
|
|
def addrgen_seed(self,name,wf,foo,desc="seed data",in_fmt="seed"):
|
|
stdout = (False,True)[int(desc=="seed data")] #capture output to screen once
|
|
add_arg = ([],["-S"])[int(stdout)]
|
|
t = MMGenExpect(name,"mmgen-addrgen", add_arg +
|
|
["-i"+in_fmt,"-d",cfg['tmpdir'],wf,cfg['addr_idx_list']])
|
|
t.license()
|
|
t.expect_getend("Valid %s for Seed ID " % desc)
|
|
vmsg("Comparing generated checksum with checksum from previous address file")
|
|
chk = t.expect_getend(r"Checksum for address data .*?: ",regex=True)
|
|
if stdout: t.read()
|
|
verify_checksum_or_exit(get_addrfile_checksum(),chk)
|
|
# t.no_overwrite()
|
|
ok()
|
|
|
|
def addrgen_mnemonic(self,name,wf,foo):
|
|
self.addrgen_seed(name,wf,foo,desc="mnemonic data",in_fmt="words")
|
|
|
|
def addrgen_incog(self,name,wf=[],foo="",in_fmt="i",
|
|
desc="incognito data",args=[]):
|
|
t = MMGenExpect(name,"mmgen-addrgen",
|
|
args+["-i"+in_fmt,"-d",cfg['tmpdir']]+
|
|
([wf] if wf else [])+
|
|
[cfg['addr_idx_list']])
|
|
t.license()
|
|
t.expect_getend("Incog Wallet ID: ")
|
|
t.hash_preset(desc,'1')
|
|
t.passphrase("%s \w{8}" % desc, cfg['wpasswd'])
|
|
vmsg("Comparing generated checksum with checksum from address file")
|
|
chk = t.expect_getend(r"Checksum for address data .*?: ",regex=True)
|
|
t.close()
|
|
verify_checksum_or_exit(get_addrfile_checksum(),chk)
|
|
# t.no_overwrite()
|
|
ok()
|
|
|
|
def addrgen_incog_hex(self,name,wf,foo):
|
|
self.addrgen_incog(name,wf,"",in_fmt="xi",desc="hex incognito data")
|
|
|
|
def addrgen_incog_hidden(self,name,wf,foo):
|
|
rf = os.path.join(cfg['tmpdir'],hincog_fn)
|
|
self.addrgen_incog(name,[],"",in_fmt="hi",desc="hidden incognito data",
|
|
args=["-H","%s,%s"%(rf,hincog_offset),"-l",str(hincog_seedlen)])
|
|
|
|
def keyaddrgen(self,name,wf,pf,check_ref=False):
|
|
args = ["-d",cfg['tmpdir'],wf,cfg['addr_idx_list']]
|
|
if ni:
|
|
m = "\nAnswer 'n' at the interactive prompt"
|
|
msg(grnbg(m))
|
|
args = ["-q","-P",pf] + args
|
|
t = MMGenExpect(name,"mmgen-keygen", args)
|
|
if ni: return
|
|
t.license()
|
|
t.passphrase("MMGen wallet",cfg['wpasswd'])
|
|
chk = t.expect_getend(r"Checksum for key-address data .*?: ",regex=True)
|
|
if check_ref:
|
|
refcheck("key-address data checksum",chk,cfg['keyaddrfile_chk'])
|
|
return
|
|
t.expect("Encrypt key list? (y/N): ","y")
|
|
t.hash_preset("new key list",'1')
|
|
t.passphrase_new("new key list",cfg['kapasswd'])
|
|
t.written_to_file("Secret keys",oo=True)
|
|
ok()
|
|
|
|
def refkeyaddrgen(self,name,wf,pf):
|
|
self.keyaddrgen(name,wf,pf,check_ref=True)
|
|
|
|
def txsign_keyaddr(self,name,keyaddr_file,txfile):
|
|
t = MMGenExpect(name,"mmgen-txsign", ["-d",cfg['tmpdir'],"-M",keyaddr_file,txfile])
|
|
t.license()
|
|
t.hash_preset("key-address file",'1')
|
|
t.passphrase("key-address file",cfg['kapasswd'])
|
|
t.expect("Check key-to-address validity? (y/N): ","y")
|
|
t.tx_view()
|
|
self.txsign_end(t)
|
|
ok()
|
|
|
|
def walletgen2(self,name):
|
|
self.walletgen(name,seed_len=128)
|
|
|
|
def addrgen2(self,name,wf):
|
|
self.addrgen(name,wf,pf="")
|
|
|
|
def txcreate2(self,name,addrfile):
|
|
self.txcreate_common(name,sources=['2'])
|
|
|
|
def txsign2(self,name,txf1,wf1,txf2,wf2):
|
|
t = MMGenExpect(name,"mmgen-txsign", ["-d",cfg['tmpdir'],txf1,wf1,txf2,wf2])
|
|
t.license()
|
|
for cnum in ('1','2'):
|
|
t.tx_view()
|
|
t.passphrase("MMGen wallet",cfgs[cnum]['wpasswd'])
|
|
self.txsign_end(t,cnum)
|
|
ok()
|
|
|
|
def export_mnemonic2(self,name,wf):
|
|
self.export_mnemonic(name,wf)
|
|
|
|
def walletgen3(self,name):
|
|
self.walletgen(name)
|
|
|
|
def addrgen3(self,name,wf):
|
|
self.addrgen(name,wf,pf="")
|
|
|
|
def txcreate3(self,name,addrfile1,addrfile2):
|
|
self.txcreate_common(name,sources=['1','3'])
|
|
|
|
def txsign3(self,name,wf1,wf2,txf2):
|
|
t = MMGenExpect(name,"mmgen-txsign", ["-d",cfg['tmpdir'],wf1,wf2,txf2])
|
|
t.license()
|
|
t.tx_view()
|
|
for cnum in ('1','3'):
|
|
# t.expect_getend("Getting MMGen wallet data from file ")
|
|
t.passphrase("MMGen wallet",cfgs[cnum]['wpasswd'])
|
|
self.txsign_end(t)
|
|
ok()
|
|
|
|
def walletgen4(self,name):
|
|
bwf = os.path.join(cfg['tmpdir'],cfg['bw_filename'])
|
|
make_brainwallet_file(bwf)
|
|
seed_len = str(cfg['seed_len'])
|
|
args = ["-d",cfg['tmpdir'],"-p1","-r10","-l"+seed_len,"-ib"]
|
|
t = MMGenExpect(name,"mmgen-walletconv", args + [bwf])
|
|
t.license()
|
|
t.passphrase_new("new MMGen wallet",cfg['wpasswd'])
|
|
t.usr_rand(10)
|
|
t.label()
|
|
t.written_to_file("MMGen wallet")
|
|
ok()
|
|
|
|
def addrgen4(self,name,wf):
|
|
self.addrgen(name,wf,pf="")
|
|
|
|
def txcreate4(self,name,f1,f2,f3,f4):
|
|
self.txcreate_common(name,sources=['1','2','3','4'],non_mmgen_input='4')
|
|
|
|
def txsign4(self,name,f1,f2,f3,f4,f5):
|
|
non_mm_fn = os.path.join(cfg['tmpdir'],non_mmgen_fn)
|
|
t = MMGenExpect(name,"mmgen-txsign",
|
|
["-d",cfg['tmpdir'],"-i","brain","-b"+cfg['bw_params'],"-p1","-k",non_mm_fn,f1,f2,f3,f4,f5])
|
|
t.license()
|
|
t.tx_view()
|
|
|
|
for cnum,desc in ('1',"incognito data"),('3',"MMGen wallet"):
|
|
t.passphrase(("%s" % desc),cfgs[cnum]['wpasswd'])
|
|
|
|
self.txsign_end(t)
|
|
ok()
|
|
|
|
def tool_encrypt(self,name,infile=""):
|
|
if infile:
|
|
infn = infile
|
|
else:
|
|
d = os.urandom(1033)
|
|
tmp_fn = cfg['tool_enc_infn']
|
|
write_to_tmpfile(cfg,tmp_fn,d,binary=True)
|
|
infn = get_tmpfile_fn(cfg,tmp_fn)
|
|
if ni:
|
|
pwfn = 'ni_pw'
|
|
write_to_tmpfile(cfg,pwfn,tool_enc_passwd+"\n")
|
|
pre = ["-P", get_tmpfile_fn(cfg,pwfn)]
|
|
app = ["hash_preset=1"]
|
|
else:
|
|
pre,app = [],[]
|
|
t = MMGenExpect(name,"mmgen-tool",pre+["-d",cfg['tmpdir'],"encrypt",infn]+app)
|
|
if ni: return
|
|
t.hash_preset("user data",'1')
|
|
t.passphrase_new("user data",tool_enc_passwd)
|
|
t.written_to_file("Encrypted data")
|
|
ok()
|
|
|
|
# Generate the reference mmenc file
|
|
# def tool_encrypt_ref(self,name):
|
|
# infn = get_tmpfile_fn(cfg,cfg['tool_enc_ref_infn'])
|
|
# write_data_to_file(infn,cfg['tool_enc_reftext'],silent=True)
|
|
# self.tool_encrypt(name,infn)
|
|
|
|
def tool_decrypt(self,name,f1,f2):
|
|
of = name + ".out"
|
|
if ni:
|
|
pwfn = 'ni_pw'
|
|
pre = ["-P", get_tmpfile_fn(cfg,pwfn)]
|
|
else:
|
|
pre = []
|
|
t = MMGenExpect(name,"mmgen-tool",
|
|
pre+["-d",cfg['tmpdir'],"decrypt",f2,"outfile="+of,"hash_preset=1"])
|
|
if not ni:
|
|
t.passphrase("user data",tool_enc_passwd)
|
|
t.written_to_file("Decrypted data")
|
|
d1 = read_from_file(f1,binary=True)
|
|
d2 = read_from_file(get_tmpfile_fn(cfg,of),binary=True)
|
|
cmp_or_die(d1,d2,skip_ok=ni)
|
|
|
|
def tool_find_incog_data(self,name,f1,f2):
|
|
i_id = read_from_file(f2).rstrip()
|
|
vmsg("Incog ID: %s" % cyan(i_id))
|
|
t = MMGenExpect(name,"mmgen-tool",
|
|
["-d",cfg['tmpdir'],"find_incog_data",f1,i_id])
|
|
if ni: return
|
|
o = t.expect_getend("Incog data for ID %s found at offset " % i_id)
|
|
os.unlink(f1)
|
|
cmp_or_die(hincog_offset,int(o))
|
|
|
|
def pywallet(self,name): # TODO - check output
|
|
pf = get_tmpfile_fn(cfg,pwfile)
|
|
write_data_to_file(pf,cfg['wpasswd']+"\n",silent=True)
|
|
args = ["-q","-P",pf] if ni else []
|
|
unenc_wf = os.path.join(ref_dir,"wallet-unenc.dat")
|
|
enc_wf = os.path.join(ref_dir,"wallet-enc.dat")
|
|
for wf,enc in (unenc_wf,False),(enc_wf,True):
|
|
for w,o,pk in (
|
|
("addresses","a",False),
|
|
("private keys","k",True),
|
|
("json dump","j",True)
|
|
):
|
|
ed = "(%sencrypted wallet, %s)" % (("un","")[int(enc)],w)
|
|
t = MMGenExpect(name,"mmgen-pywallet", args +
|
|
["-"+o,"-d",cfg['tmpdir']] + [wf], extra_desc=ed)
|
|
if ni: continue
|
|
if pk and enc and not ni:
|
|
t.expect("Enter password: ",cfg['wpasswd']+"\n")
|
|
t.written_to_file(capfirst(w),oo=True)
|
|
if not ni: ok()
|
|
|
|
# Saved reference file tests
|
|
def ref_wallet_conv(self,name):
|
|
wf = os.path.join(ref_dir,cfg['ref_wallet'])
|
|
self.walletconv_in(name,wf,"MMGen wallet",pw=True,oo=True)
|
|
|
|
def ref_mn_conv(self,name,ext="mmwords",desc="Mnemonic data"):
|
|
wf = os.path.join(ref_dir,cfg['seed_id']+"."+ext)
|
|
self.walletconv_in(name,wf,desc,oo=True)
|
|
|
|
def ref_seed_conv(self,name):
|
|
self.ref_mn_conv(name,ext="mmseed",desc="Seed data")
|
|
|
|
def ref_brain_conv(self,name):
|
|
uopts = ["-i","b","-p","1","-l",str(cfg['seed_len'])]
|
|
self.walletconv_in(name,None,"brainwallet",uopts,oo=True)
|
|
|
|
def ref_incog_conv(self,name,wfk="ic_wallet",in_fmt="i",desc="incognito data"):
|
|
uopts = ["-i",in_fmt,"-p","1","-l",str(cfg['seed_len'])]
|
|
wf = os.path.join(ref_dir,cfg[wfk])
|
|
self.walletconv_in(name,wf,desc,uopts,oo=True,pw=True)
|
|
|
|
def ref_incox_conv(self,name):
|
|
self.ref_incog_conv(name,in_fmt="xi",wfk="ic_wallet_hex",desc="hex incognito data")
|
|
|
|
def ref_hincog_conv(self,name,wfk='hic_wallet',add_uopts=[]):
|
|
ic_f = os.path.join(ref_dir,cfg[wfk])
|
|
uopts = ["-i","hi","-p","1","-l",str(cfg['seed_len'])] + add_uopts
|
|
hi_opt = ["-H","%s,%s" % (ic_f,ref_wallet_incog_offset)]
|
|
self.walletconv_in(name,None,"hidden incognito data",uopts+hi_opt,oo=True,pw=True)
|
|
|
|
def ref_hincog_conv_old(self,name):
|
|
self.ref_hincog_conv(name,wfk='hic_wallet_old',add_uopts=["-O"])
|
|
|
|
def ref_wallet_conv_out(self,name):
|
|
self.walletconv_out(name,"MMGen wallet","w",pw=True)
|
|
|
|
def ref_mn_conv_out(self,name):
|
|
self.walletconv_out(name,"mnemonic data","mn")
|
|
|
|
def ref_seed_conv_out(self,name):
|
|
self.walletconv_out(name,"seed data","seed")
|
|
|
|
def ref_incog_conv_out(self,name):
|
|
self.walletconv_out(name,"incognito data",out_fmt="i",pw=True)
|
|
|
|
def ref_incox_conv_out(self,name):
|
|
self.walletconv_out(name,"hex incognito data",out_fmt="xi",pw=True)
|
|
|
|
def ref_hincog_conv_out(self,name,extra_uopts=[]):
|
|
ic_f = os.path.join(cfg['tmpdir'],hincog_fn)
|
|
hi_parms = "%s,%s" % (ic_f,ref_wallet_incog_offset)
|
|
sl_parm = "-l" + str(cfg['seed_len'])
|
|
self.walletconv_out(name,
|
|
"hidden incognito data", "hi",
|
|
uopts=["-J",hi_parms,sl_parm] + extra_uopts,
|
|
uopts_chk=["-H",hi_parms,sl_parm],
|
|
pw=True
|
|
)
|
|
|
|
def ref_wallet_chk(self,name):
|
|
wf = os.path.join(ref_dir,cfg['ref_wallet'])
|
|
if ni:
|
|
write_to_tmpfile(cfg,pwfile,cfg['wpasswd'])
|
|
pf = get_tmpfile_fn(cfg,pwfile)
|
|
else:
|
|
pf = None
|
|
self.walletchk(name,wf,pf=pf,pw=True,sid=cfg['seed_id'])
|
|
|
|
def ref_seed_chk(self,name,ext=g.seed_ext):
|
|
wf = os.path.join(ref_dir,"%s.%s" % (cfg['seed_id'],ext))
|
|
desc = "seed data" if ext == g.seed_ext else "mnemonic data"
|
|
self.walletchk(name,wf,pf=None,desc=desc,sid=cfg['seed_id'])
|
|
|
|
def ref_mn_chk(self,name): self.ref_seed_chk(name,ext=g.mn_ext)
|
|
|
|
def ref_brain_chk(self,name,bw_file=ref_bw_file):
|
|
wf = os.path.join(ref_dir,bw_file)
|
|
add_args = ["-l%s" % cfg['seed_len'], "-p"+ref_bw_hash_preset]
|
|
self.walletchk(name,wf,pf=None,add_args=add_args,
|
|
desc="brainwallet",sid=cfg['ref_bw_seed_id'])
|
|
|
|
def ref_brain_chk_spc3(self,name):
|
|
self.ref_brain_chk(name,bw_file=ref_bw_file_spc)
|
|
|
|
def ref_hincog_chk(self,name,desc="hidden incognito data"):
|
|
for wtype,edesc,of_arg in ('hic_wallet','',[]), \
|
|
('hic_wallet_old','(old format)',["-O"]):
|
|
ic_arg = ["-H%s,%s" % (
|
|
os.path.join(ref_dir,cfg[wtype]),
|
|
ref_wallet_incog_offset
|
|
)]
|
|
slarg = ["-l%s " % cfg['seed_len']]
|
|
hparg = ["-p1"]
|
|
if ni:
|
|
write_to_tmpfile(cfg,pwfile,cfg['wpasswd'])
|
|
add_args = ["-q","-P%s" % get_tmpfile_fn(cfg,pwfile)]
|
|
else:
|
|
add_args = []
|
|
if ni and wtype == 'hic_wallet_old':
|
|
m = grnbg("Answer 'y' at the interactive prompt if Seed ID is")
|
|
n = cyan(cfg['seed_id'])
|
|
msg("\n%s %s" % (m,n))
|
|
t = MMGenExpect(name,"mmgen-walletchk",
|
|
add_args + slarg + hparg + of_arg + ic_arg,
|
|
extra_desc=edesc)
|
|
if ni: continue
|
|
t.passphrase(desc,cfg['wpasswd'])
|
|
if wtype == 'hic_wallet_old':
|
|
t.expect("Is the Seed ID correct? (Y/n): ","\n")
|
|
chk = t.expect_getend("Seed ID: ")
|
|
t.close()
|
|
cmp_or_die(cfg['seed_id'],chk)
|
|
|
|
def ref_addrfile_chk(self,name,ftype="addr"):
|
|
wf = os.path.join(ref_dir,cfg['ref_'+ftype+'file'])
|
|
if ni:
|
|
m = "\nAnswer the interactive prompts as follows: '1'<ENTER>, ENTER"
|
|
msg(grnbg(m))
|
|
pfn = "ref_kafile_passwd"
|
|
write_to_tmpfile(cfg,pfn,ref_kafile_pass)
|
|
aa = ["-P",get_tmpfile_fn(cfg,pfn)]
|
|
else:
|
|
aa = []
|
|
t = MMGenExpect(name,"mmgen-tool",aa+[ftype+"file_chksum",wf])
|
|
if ni:
|
|
k = 'ref_%saddrfile_chksum' % ('key' if ftype == "keyaddr" else '')
|
|
m = grnbg("Checksum should be:")
|
|
n = cyan(cfg[k])
|
|
msg(grnbg("%s %s" % (m,n)))
|
|
return
|
|
if ftype == "keyaddr":
|
|
w = "key-address file"
|
|
t.hash_preset(w,ref_kafile_hash_preset)
|
|
t.passphrase(w,ref_kafile_pass)
|
|
t.expect("Check key-to-address validity? (y/N): ","y")
|
|
o = t.expect_getend("Checksum for .*address data .*: ",regex=True)
|
|
cmp_or_die(cfg['ref_'+ftype+'file_chksum'],o)
|
|
|
|
def ref_keyaddrfile_chk(self,name):
|
|
self.ref_addrfile_chk(name,ftype="keyaddr")
|
|
|
|
# def txcreate8(self,name,addrfile):
|
|
# self.txcreate_common(name,sources=['8'])
|
|
|
|
def ref_tx_chk(self,name):
|
|
tf = os.path.join(ref_dir,cfg['ref_tx_file'])
|
|
wf = os.path.join(ref_dir,cfg['ref_wallet'])
|
|
write_to_tmpfile(cfg,pwfile,cfg['wpasswd'])
|
|
pf = get_tmpfile_fn(cfg,pwfile)
|
|
self.txsign(name,tf,wf,pf,save=False)
|
|
|
|
def ref_tool_decrypt(self,name):
|
|
f = os.path.join(ref_dir,ref_enc_fn)
|
|
aa = []
|
|
if ni:
|
|
pfn = "tool_enc_passwd"
|
|
write_to_tmpfile(cfg,pfn,tool_enc_passwd)
|
|
aa = ["-P",get_tmpfile_fn(cfg,pfn)]
|
|
t = MMGenExpect(name,"mmgen-tool",
|
|
aa + ["-q","decrypt",f,"outfile=-","hash_preset=1"])
|
|
if ni: return
|
|
t.passphrase("user data",tool_enc_passwd)
|
|
t.readline()
|
|
import re
|
|
o = re.sub('\r\n','\n',t.read())
|
|
cmp_or_die(sample_text,o)
|
|
|
|
# wallet conversion tests
|
|
def walletconv_in(self,name,infile,desc,uopts=[],pw=False,oo=False):
|
|
opts = ["-d",cfg['tmpdir'],"-o","words","-r10"]
|
|
if_arg = [infile] if infile else []
|
|
d = "(convert)"
|
|
if ni:
|
|
opts += ["-q"]
|
|
msg("")
|
|
if pw:
|
|
pfn = "ni_passwd"
|
|
write_to_tmpfile(cfg,pfn,cfg['wpasswd'])
|
|
opts += ["-P",get_tmpfile_fn(cfg,pfn)]
|
|
if desc == "brainwallet":
|
|
m = "\nAnswer the interactive prompt as follows: '%s'<ENTER>"
|
|
msg(grnbg(m % ref_wallet_brainpass))
|
|
if "-O" in uopts:
|
|
m = grnbg("Answer 'y' at the interactive prompt if Seed ID is")
|
|
n = cyan(cfg['seed_id'])
|
|
msg("\n%s %s" % (m,n))
|
|
t = MMGenExpect(name,"mmgen-walletconv",opts+uopts+if_arg,extra_desc=d)
|
|
if ni:
|
|
m = grnbg("Seed ID should be:")
|
|
n = cyan(cfg['seed_id'])
|
|
msg(grnbg("%s %s" % (m,n)))
|
|
return
|
|
t.license()
|
|
if desc == "brainwallet":
|
|
t.expect("Enter brainwallet: ",ref_wallet_brainpass+"\n")
|
|
if pw:
|
|
t.passphrase(desc,cfg['wpasswd'])
|
|
if name[:19] == "ref_hincog_conv_old":
|
|
t.expect("Is the Seed ID correct? (Y/n): ","\n")
|
|
else:
|
|
t.expect(["Passphrase is OK"," are correct"])
|
|
# Output
|
|
wf = t.written_to_file("Mnemonic data",oo=oo)
|
|
t.close()
|
|
ok()
|
|
# back check of result
|
|
self.walletchk(name,wf,pf=None,
|
|
desc="mnemonic data",
|
|
sid=cfg['seed_id'],
|
|
extra_desc="(check)"
|
|
)
|
|
|
|
def walletconv_out(self,name,desc,out_fmt="w",uopts=[],uopts_chk=[],pw=False):
|
|
opts = ["-d",cfg['tmpdir'],"-p1","-o",out_fmt] + uopts
|
|
if ni:
|
|
pfn = "ni_passwd"
|
|
write_to_tmpfile(cfg,pfn,cfg['wpasswd'])
|
|
l = "Non-Interactive Test Wallet"
|
|
aa = ["-q","-L",l,"-r0","-P",get_tmpfile_fn(cfg,pfn)]
|
|
if desc == "hidden incognito data":
|
|
rd = os.urandom(ref_wallet_incog_offset+128)
|
|
write_to_tmpfile(cfg,hincog_fn,rd)
|
|
else:
|
|
aa = ["-r10"]
|
|
infile = os.path.join(ref_dir,cfg['seed_id']+".mmwords")
|
|
t = MMGenExpect(name,"mmgen-walletconv",aa+opts+[infile],extra_desc="(convert)")
|
|
|
|
add_args = ["-l%s" % cfg['seed_len']]
|
|
if ni:
|
|
pfn = "ni_passwd"
|
|
write_to_tmpfile(cfg,pfn,cfg['wpasswd'])
|
|
pf = get_tmpfile_fn(cfg,pfn)
|
|
if desc != "hidden incognito data":
|
|
from mmgen.seed import SeedSource
|
|
ext = SeedSource.fmt_code_to_sstype(out_fmt).ext
|
|
hps = ("",",1")[int(pw)] # TODO real hp
|
|
pre_ext = "[%s%s]." % (cfg['seed_len'],hps)
|
|
wf = get_file_with_ext(pre_ext+ext,cfg['tmpdir'],no_dot=True)
|
|
else:
|
|
t.license()
|
|
if pw:
|
|
t.passphrase_new("new "+desc,cfg['wpasswd'])
|
|
t.usr_rand(10)
|
|
if " ".join(desc.split()[-2:]) == "incognito data":
|
|
for i in (1,2,3):
|
|
t.expect("Generating encryption key from OS random data ")
|
|
if desc == "hidden incognito data":
|
|
ret = t.expect(["Create? (Y/n): ","'YES' to confirm: "])
|
|
if ret == 0:
|
|
t.send("\n")
|
|
t.expect("Enter file size: ",str(hincog_bytes)+"\n")
|
|
else:
|
|
t.send("YES\n")
|
|
if out_fmt == "w": t.label()
|
|
wf = t.written_to_file(capfirst(desc),oo=True)
|
|
pf = None
|
|
ok()
|
|
|
|
if desc == "hidden incognito data":
|
|
add_args += uopts_chk
|
|
wf = None
|
|
self.walletchk(name,wf,pf=pf,
|
|
desc=desc,sid=cfg['seed_id'],pw=pw,
|
|
add_args=add_args,
|
|
extra_desc="(check)")
|
|
|
|
for k in (
|
|
"ref_wallet_conv",
|
|
"ref_mn_conv",
|
|
"ref_seed_conv",
|
|
"ref_brain_conv",
|
|
"ref_incog_conv",
|
|
"ref_incox_conv",
|
|
"ref_hincog_conv",
|
|
"ref_hincog_conv_old",
|
|
"ref_wallet_conv_out",
|
|
"ref_mn_conv_out",
|
|
"ref_seed_conv_out",
|
|
"ref_incog_conv_out",
|
|
"ref_incox_conv_out",
|
|
"ref_hincog_conv_out",
|
|
"ref_wallet_chk",
|
|
"refwalletgen",
|
|
"refaddrgen",
|
|
"ref_seed_chk",
|
|
"ref_mn_chk",
|
|
"ref_brain_chk",
|
|
"ref_hincog_chk",
|
|
"refkeyaddrgen",
|
|
):
|
|
for i in ('1','2','3'):
|
|
locals()[k+i] = locals()[k]
|
|
|
|
|
|
# main()
|
|
if opt.pause:
|
|
import termios,atexit
|
|
fd = sys.stdin.fileno()
|
|
old = termios.tcgetattr(fd)
|
|
def at_exit():
|
|
termios.tcsetattr(fd, termios.TCSADRAIN, old)
|
|
atexit.register(at_exit)
|
|
|
|
start_time = int(time.time())
|
|
ts = MMGenTestSuite()
|
|
|
|
for cfg in sorted(cfgs): mk_tmpdir(cfgs[cfg])
|
|
|
|
try:
|
|
if cmd_args:
|
|
for arg in cmd_args:
|
|
if arg in utils:
|
|
globals()[arg](cmd_args[cmd_args.index(arg)+1:])
|
|
sys.exit()
|
|
elif "info_"+arg in cmd_data:
|
|
dirs = cmd_data["info_"+arg][1]
|
|
if dirs: clean(dirs)
|
|
for cmd in cmd_list[arg]:
|
|
check_needs_rerun(ts,cmd,build=True)
|
|
elif arg in meta_cmds:
|
|
for cmd in meta_cmds[arg]:
|
|
check_needs_rerun(ts,cmd,build=True)
|
|
elif arg in cmd_data:
|
|
check_needs_rerun(ts,arg,build=True)
|
|
else:
|
|
die(1,"%s: unrecognized command" % arg)
|
|
else:
|
|
clean()
|
|
for cmd in cmd_data:
|
|
if cmd[:5] == "info_":
|
|
msg(green("\nTesting " + cmd_data[cmd][0]))
|
|
continue
|
|
ts.do_cmd(cmd)
|
|
if cmd is not cmd_data.keys()[-1]: do_between()
|
|
except:
|
|
sys.stderr = stderr_save
|
|
raise
|
|
|
|
t = int(time.time()) - start_time
|
|
sys.stderr.write(green(
|
|
"All requested tests finished OK, elapsed time: %02i:%02i\n"
|
|
% (t/60,t%60)))
|