def main():
parser = ArgumentParser()
parser.add_argument("-m", dest="mnemonic", help="Set mnemonic", type=str)
parser.add_argument("-p", dest="pin", help="Set pin", type=str)
parser.add_argument("--passphrase",
dest="passphrase",
help="Enable passphrase",
action="store_true")
parser.add_argument("--no-passphrase",
dest="passphrase",
help="Enable passphrase",
action="store_false")
parser.set_defaults(passphrase=True)
args = parser.parse_args()
# Setup link
wirelink = get_device()
client = TrezorClientDebugLink(wirelink)
client.open()
device.wipe(client)
debuglink.load_device_by_mnemonic(client,
mnemonic=args.mnemonic,
pin=args.pin,
passphrase_protection=args.passphrase,
label='test')
print(args.mnemonic)
print(client.features)
client.close()
def test_load_device(self, client):
with client:
client.set_expected_responses(
[proto.ButtonRequest(), proto.Success(), proto.Features()]
)
debuglink.load_device_by_mnemonic(
client,
"this is mnemonic",
"1234",
True,
"label",
"english",
skip_checksum=True,
)
with pytest.raises(TrezorFailure):
# This must fail, because device is already initialized
# Using direct call because `load_device_by_mnemonic` has its own check
client.call(
proto.LoadDevice(
mnemonics="this is mnemonic",
pin="1234",
passphrase_protection=True,
language="english",
label="label",
skip_checksum=True,
)
)
def test_sd_protect(self, client):
# Disabling SD protection should fail
with pytest.raises(TrezorFailure):
device.sd_protect(client, proto.SdProtectOperationType.DISABLE)
# Enable SD protection
device.sd_protect(client, proto.SdProtectOperationType.ENABLE)
# Enabling SD protection should fail
with pytest.raises(TrezorFailure):
device.sd_protect(client, proto.SdProtectOperationType.ENABLE)
# Wipe
device.wipe(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC12,
pin="",
passphrase_protection=False,
label="test",
)
# Enable SD protection
device.sd_protect(client, proto.SdProtectOperationType.ENABLE)
# Refresh SD protection
device.sd_protect(client, proto.SdProtectOperationType.REFRESH)
# Disable SD protection
device.sd_protect(client, proto.SdProtectOperationType.DISABLE)
# Refreshing SD protection should fail
with pytest.raises(TrezorFailure):
device.sd_protect(client, proto.SdProtectOperationType.REFRESH)
def test_load_device(self):
with self.client:
self.client.set_expected_responses(
[proto.ButtonRequest(),
proto.Success(),
proto.Features()])
debuglink.load_device_by_mnemonic(
self.client,
"this is mnemonic",
"1234",
True,
"label",
"english",
skip_checksum=True,
)
# This must fail, because device is already initialized
with pytest.raises(Exception):
debuglink.load_device_by_mnemonic(
self.client,
"this is mnemonic",
"1234",
True,
"label",
"english",
skip_checksum=True,
)
def test_upgrade_load_pin(gen, tag):
PIN = "1234"
def asserts(client):
assert client.features.pin_protection
assert not client.features.passphrase_protection
assert client.features.initialized
assert client.features.label == LABEL
client.use_pin_sequence([PIN])
assert btc.get_address(client, "Bitcoin", PATH) == ADDRESS
with EmulatorWrapper(gen, tag) as emu:
debuglink.load_device_by_mnemonic(
emu.client,
mnemonic=MNEMONIC,
pin=PIN,
passphrase_protection=False,
label=LABEL,
language=LANGUAGE,
)
device_id = emu.client.features.device_id
asserts(emu.client)
storage = emu.get_storage()
with EmulatorWrapper(gen, storage=storage) as emu:
assert device_id == emu.client.features.device_id
asserts(emu.client)
assert emu.client.features.language == LANGUAGE
def test_upgrade_load(gen, from_tag, to_tag):
def asserts(tag, client):
assert not client.features.pin_protection
assert not client.features.passphrase_protection
assert client.features.initialized
assert client.features.label == LABEL
assert client.features.language == LANGUAGE
assert btc.get_address(client, "Bitcoin", PATH) == ADDRESS
with EmulatorWrapper(gen, from_tag) as emu:
debuglink.load_device_by_mnemonic(
emu.client,
mnemonic=MNEMONIC,
pin="",
passphrase_protection=False,
label=LABEL,
language=LANGUAGE,
)
device_id = emu.client.features.device_id
asserts(from_tag, emu.client)
storage = emu.storage()
with EmulatorWrapper(gen, to_tag, storage=storage) as emu:
assert device_id == emu.client.features.device_id
asserts(to_tag, emu.client)
def test_load_device(self):
with self.client:
self.client.set_expected_responses(
[proto.ButtonRequest(), proto.Success(), proto.Features()]
)
debuglink.load_device_by_mnemonic(
self.client,
"this is mnemonic",
"1234",
True,
"label",
"english",
skip_checksum=True,
)
# This must fail, because device is already initialized
with pytest.raises(Exception):
debuglink.load_device_by_mnemonic(
self.client,
"this is mnemonic",
"1234",
True,
"label",
"english",
skip_checksum=True,
)
def test_load_device_slip39_advanced(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC_SLIP39_ADVANCED_20,
pin="",
passphrase_protection=False,
label="test",
)
assert client.features.backup_type == BackupType.Slip39_Advanced
def test_load_device_slip39_basic(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC_SLIP39_BASIC_20_3of6,
pin="",
passphrase_protection=False,
label="test",
)
assert client.features.backup_type == BackupType.Slip39_Basic
def wrapper(client, *args, **kwargs):
debuglink.load_device_by_mnemonic(
client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
return function(client, *args, **kwargs)
def wrapper(client, *args, **kwargs):
debuglink.load_device_by_mnemonic(
client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
return function(client, *args, **kwargs)
def test_mnemonic(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC12,
pin="",
passphrase_protection=False,
label="test",
)
mnemonic = client.debug.state().mnemonic_secret
assert mnemonic == self.mnemonic12.encode()
def _setup_mnemonic(self, mnemonic=None, pin="", passphrase=False):
if mnemonic is None:
mnemonic = TrezorTest.mnemonic12
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
def wrapper(client, *args, **kwargs):
debuglink.load_device_by_mnemonic(
client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
if TREZOR_VERSION > 1 and passphrase:
apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
return function(*args, client=client, **kwargs)
def test_ripple_get_address_other(self):
# data from https://github.com/you21979/node-ripple-bip32/blob/master/test/test.js
debuglink.load_device_by_mnemonic(
self.client,
mnemonic="armed bundle pudding lazy strategy impulse where identify submit weekend physical antenna flight social acoustic absurd whip snack decide blur unfold fiction pumpkin athlete",
pin="",
passphrase_protection=False,
label="test",
language="english",
)
address = get_address(self.client, parse_path("m/44'/144'/0'/0/0"))
assert address == "r4ocGE47gm4G4LkA9mriVHQqzpMLBTgnTY"
address = get_address(self.client, parse_path("m/44'/144'/0'/0/1"))
assert address == "rUt9ULSrUvfCmke8HTFU1szbmFpWzVbBXW"
def test_ripple_get_address_other(self):
# data from https://github.com/you21979/node-ripple-bip32/blob/master/test/test.js
debuglink.load_device_by_mnemonic(
self.client,
mnemonic="armed bundle pudding lazy strategy impulse where identify submit weekend physical antenna flight social acoustic absurd whip snack decide blur unfold fiction pumpkin athlete",
pin="",
passphrase_protection=False,
label="test",
language="english",
)
address = get_address(self.client, parse_path("m/44'/144'/0'/0/0"))
assert address == "r4ocGE47gm4G4LkA9mriVHQqzpMLBTgnTY"
address = get_address(self.client, parse_path("m/44'/144'/0'/0/1"))
assert address == "rUt9ULSrUvfCmke8HTFU1szbmFpWzVbBXW"
def _setup_mnemonic(self, mnemonic=None, pin="", passphrase=False):
if mnemonic is None:
mnemonic = TrezorTest.mnemonic12
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
if conftest.TREZOR_VERSION > 1 and passphrase:
device.apply_settings(self.client,
passphrase_source=PASSPHRASE_ON_HOST)
def test_load_device_1(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC12,
pin="",
passphrase_protection=False,
label="test",
)
state = client.debug.state()
assert state.mnemonic_secret == MNEMONIC12.encode()
assert state.pin is None
assert state.passphrase_protection is False
address = btc.get_address(client, "Bitcoin", [])
assert address == "1EfKbQupktEMXf4gujJ9kCFo83k1iMqwqK"
def _setup_mnemonic(self, mnemonic=None, pin="", passphrase=False, lock=True):
if mnemonic is None:
mnemonic = TrezorTest.mnemonic12
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
if conftest.TREZOR_VERSION == 1 and lock:
# remove cached PIN (introduced via load_device)
self.client.clear_session()
if conftest.TREZOR_VERSION > 1 and passphrase:
device.apply_settings(self.client, passphrase_source=PASSPHRASE_ON_HOST)
def _setup_mnemonic(self, mnemonic=None, pin="", passphrase=False, lock=True):
if mnemonic is None:
mnemonic = TrezorTest.mnemonic12
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=mnemonic,
pin=pin,
passphrase_protection=passphrase,
label="test",
language="english",
)
if conftest.TREZOR_VERSION == 1 and lock:
# remove cached PIN (introduced via load_device)
self.client.clear_session()
if conftest.TREZOR_VERSION > 1 and passphrase:
device.apply_settings(self.client, passphrase_source=PASSPHRASE_ON_HOST)
def test_load_device_2(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC12,
pin="1234",
passphrase_protection=True,
label="test",
)
client.set_passphrase("passphrase")
state = client.debug.state()
assert state.mnemonic_secret == MNEMONIC12.encode()
assert state.pin == "1234"
assert state.passphrase_protection is True
address = btc.get_address(client, "Bitcoin", [])
assert address == "15fiTDFwZd2kauHYYseifGi9daH2wniDHH"
def test_tron_getaddress(self):
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
pin="",
passphrase_protection=False,
label="test",
language="english",
)
assert (tron.get_address(self.client, parse_path("m/44'/195'/0'/0/0"))
== "TUEZSdKsoDHQMeZwihtdoBiN46zxhGWYdH")
assert (tron.get_address(self.client, parse_path("m/44'/195'/1'/0/0"))
== "TLrpNTBuCpGMrB9TyVwgEhNVRhtWEQPHh4")
assert (tron.get_address(self.client, parse_path("m/44'/195'/2'/0/0"))
== "TZJ9qkoxUB1SGdbtChgAjUphBmkJwAeBaW")
assert (tron.get_address(self.client, parse_path("m/44'/195'/1'/0/1"))
== "TUT9qMmtJtnjJhpazPaLraWSTaThhBpWyR")
def test_upgrade_wipe_code(gen, tag):
PIN = "1234"
WIPE_CODE = "4321"
def asserts(client):
assert client.features.pin_protection
assert not client.features.passphrase_protection
assert client.features.initialized
assert client.features.label == LABEL
client.use_pin_sequence([PIN])
assert btc.get_address(client, "Bitcoin", PATH) == ADDRESS
with EmulatorWrapper(gen, tag) as emu:
debuglink.load_device_by_mnemonic(
emu.client,
mnemonic=MNEMONIC,
pin=PIN,
passphrase_protection=False,
label=LABEL,
language=LANGUAGE,
)
# Set wipe code.
emu.client.use_pin_sequence([PIN, WIPE_CODE, WIPE_CODE])
device.change_wipe_code(emu.client)
device_id = emu.client.features.device_id
asserts(emu.client)
storage = emu.get_storage()
with EmulatorWrapper(gen, storage=storage) as emu:
assert device_id == emu.client.features.device_id
asserts(emu.client)
assert emu.client.features.language == LANGUAGE
# Check that wipe code is set by changing the PIN to it.
emu.client.use_pin_sequence([PIN, WIPE_CODE, WIPE_CODE])
with pytest.raises(
exceptions.TrezorFailure,
match="The new PIN must be different from your wipe code",
):
return device.change_pin(emu.client)
def test_stellar_get_address_sep(self):
# data from https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=
"illness spike retreat truth genius clock brain pass fit cave bargain toe",
pin="",
passphrase_protection=False,
label="test",
language="english",
)
address = stellar.get_address(self.client,
parse_path(stellar.DEFAULT_BIP32_PATH))
assert address == "GDRXE2BQUC3AZNPVFSCEZ76NJ3WWL25FYFK6RGZGIEKWE4SOOHSUJUJ6"
address = stellar.get_address(self.client,
parse_path("m/44h/148h/1h"),
show_display=True)
assert address == "GBAW5XGWORWVFE2XTJYDTLDHXTY2Q2MO73HYCGB3XMFMQ562Q2W2GJQX"
def test_stellar_get_address_sep(self):
# data from https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0005.md
debuglink.load_device_by_mnemonic(
self.client,
mnemonic="illness spike retreat truth genius clock brain pass fit cave bargain toe",
pin="",
passphrase_protection=False,
label="test",
language="english",
)
address = stellar.get_address(
self.client, parse_path(stellar.DEFAULT_BIP32_PATH)
)
assert address == "GDRXE2BQUC3AZNPVFSCEZ76NJ3WWL25FYFK6RGZGIEKWE4SOOHSUJUJ6"
address = stellar.get_address(
self.client, parse_path("m/44h/148h/1h"), show_display=True
)
assert address == "GBAW5XGWORWVFE2XTJYDTLDHXTY2Q2MO73HYCGB3XMFMQ562Q2W2GJQX"
def load_client():
try:
client = get_device()
except RuntimeError:
request.session.shouldstop = "No debuggable Trezor is available"
pytest.fail("No debuggable Trezor is available")
wipe_device(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=" ".join(["all"] * 12),
pin=None,
passphrase_protection=False,
label="test",
language="en-US",
)
client.clear_session()
client.open()
return client
def reinit_trezor(self):
self.deinit()
path = self.get_trezor_path()
is_debug = not int(os.getenv('TREZOR_NDEBUG', 0))
self.creds = self.get_trezor_creds(0)
self.trezor_proxy = tmanager.Trezor(path=path, debug=is_debug)
self.agent = agent_lite.Agent(self.trezor_proxy,
network_type=monero.NetworkTypes.TESTNET)
client = self.trezor_proxy.client
if is_debug:
client.open()
device.wipe(client)
debuglink.load_device_by_mnemonic(
client=client,
mnemonic=self.get_trezor_mnemonics()[0],
pin="",
passphrase_protection=False,
label="ph4test",
language="english",
)
def test_wipe(client):
# Enable SD protection
device.sd_protect(client, Op.ENABLE)
assert client.features.sd_protection is True
# Wipe device (this wipes internal storage)
device.wipe(client)
assert client.features.sd_protection is False
# Restore device to working status
debuglink.load_device_by_mnemonic(
client, mnemonic=MNEMONIC12, pin=None, passphrase_protection=False, label="test"
)
assert client.features.sd_protection is False
# Enable SD protection
device.sd_protect(client, Op.ENABLE)
assert client.features.sd_protection is True
# Refresh SD protection
device.sd_protect(client, Op.REFRESH)
def test_upgrade_u2f(gen, tag):
"""Check U2F counter stayed the same after an upgrade."""
with EmulatorWrapper(gen, tag) as emu:
debuglink.load_device_by_mnemonic(
emu.client,
mnemonic=MNEMONIC,
pin="",
passphrase_protection=False,
label=LABEL,
)
success = fido.set_counter(emu.client, 10)
assert "U2F counter set" in success
counter = fido.get_next_counter(emu.client)
assert counter == 11
storage = emu.get_storage()
with EmulatorWrapper(gen, storage=storage) as emu:
counter = fido.get_next_counter(emu.client)
assert counter == 12
def test_load_device_2(self, client):
debuglink.load_device_by_mnemonic(
client,
mnemonic=MNEMONIC12,
pin="1234",
passphrase_protection=True,
label="test",
)
if client.features.model == "T":
device.apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.set_passphrase("passphrase")
state = client.debug.state()
assert state.mnemonic_secret == MNEMONIC12.encode()
if client.features.model == "1":
# we do not send PIN in DebugLinkState in Core
assert state.pin == "1234"
assert state.passphrase_protection is True
address = btc.get_address(client, "Bitcoin", [])
assert address == "15fiTDFwZd2kauHYYseifGi9daH2wniDHH"
def client(request):
client = get_device()
wipe_device(client)
client.open()
# fmt: off
setup_params = dict(
uninitialized=False,
mnemonic=" ".join(["all"] * 12),
pin=None,
passphrase=False,
)
# fmt: on
marker = request.node.get_closest_marker("setup_client")
if marker:
setup_params.update(marker.kwargs)
if not setup_params["uninitialized"]:
if setup_params["pin"] is True:
setup_params["pin"] = "1234"
debuglink.load_device_by_mnemonic(
client,
mnemonic=setup_params["mnemonic"],
pin=setup_params["pin"],
passphrase_protection=setup_params["passphrase"],
label="test",
language="english",
)
client.clear_session()
if setup_params["passphrase"] and client.features.model != "1":
apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
yield client
client.close()
def load_client():
devices = enumerate_devices()
for device in devices:
try:
client = TrezorClientDebugLink(device)
break
except Exception:
pass
else:
raise RuntimeError("No debuggable device found")
wipe_device(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=" ".join(["all"] * 12),
pin=None,
passphrase_protection=False,
label="test",
language="english",
)
client.clear_session()
client.open()
return client
def test_load_device_utf(self, client):
words_nfkd = u"Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a"
words_nfc = u"P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f"
words_nfkc = u"P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f"
words_nfd = u"Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a"
passphrase_nfkd = (
u"Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko"
)
passphrase_nfc = (
u"Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko")
passphrase_nfkc = (
u"Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko")
passphrase_nfd = (
u"Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko"
)
device.wipe(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=words_nfkd,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
if client.features.model == "T":
device.apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.set_passphrase(passphrase_nfkd)
address_nfkd = btc.get_address(client, "Bitcoin", [])
device.wipe(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=words_nfc,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
if client.features.model == "T":
device.apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.set_passphrase(passphrase_nfc)
address_nfc = btc.get_address(client, "Bitcoin", [])
device.wipe(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=words_nfkc,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
if client.features.model == "T":
device.apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.set_passphrase(passphrase_nfkc)
address_nfkc = btc.get_address(client, "Bitcoin", [])
device.wipe(client)
debuglink.load_device_by_mnemonic(
client,
mnemonic=words_nfd,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
if client.features.model == "T":
device.apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.set_passphrase(passphrase_nfd)
address_nfd = btc.get_address(client, "Bitcoin", [])
assert address_nfkd == address_nfc
assert address_nfkd == address_nfkc
assert address_nfkd == address_nfd
def client(request):
"""Client fixture.
Every test function that requires a client instance will get it from here.
If we can't connect to a debuggable device, the test will fail.
If 'skip_t2' is used and TT is connected, the test is skipped. Vice versa with T1
and 'skip_t1'.
The client instance is wiped and preconfigured with "all all all..." mnemonic, no
password and no pin. It is possible to customize this with the `setup_client`
marker.
To specify a custom mnemonic and/or custom pin and/or enable passphrase:
@pytest.mark.setup_client(mnemonic=MY_MNEMONIC, pin="9999", passphrase=True)
To receive a client instance that was not initialized:
@pytest.mark.setup_client(uninitialized=True)
"""
try:
client = get_device()
except RuntimeError:
pytest.fail("No debuggable Trezor is available")
if request.node.get_closest_marker(
"skip_t2") and client.features.model == "T":
pytest.skip("Test excluded on Trezor T")
if request.node.get_closest_marker(
"skip_t1") and client.features.model == "1":
pytest.skip("Test excluded on Trezor 1")
if (request.node.get_closest_marker("sd_card")
and not client.features.sd_card_present):
raise RuntimeError("This test requires SD card.\n"
"To skip all such tests, run:\n"
" pytest -m 'not sd_card' <test path>")
wipe_device(client)
# fmt: off
setup_params = dict(
uninitialized=False,
mnemonic=" ".join(["all"] * 12),
pin=None,
passphrase=False,
)
# fmt: on
marker = request.node.get_closest_marker("setup_client")
if marker:
setup_params.update(marker.kwargs)
if not setup_params["uninitialized"]:
if setup_params["pin"] is True:
setup_params["pin"] = "1234"
debuglink.load_device_by_mnemonic(
client,
mnemonic=setup_params["mnemonic"],
pin=setup_params["pin"],
passphrase_protection=setup_params["passphrase"],
label="test",
language="english",
)
client.clear_session()
if setup_params["passphrase"] and client.features.model != "1":
apply_settings(client, passphrase_source=PASSPHRASE_ON_HOST)
client.open()
yield client
client.close()
def test_load_device_utf(self):
words_nfkd = u"Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a"
words_nfc = u"P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f"
words_nfkc = u"P\u0159\xed\u0161ern\u011b \u017elu\u0165ou\u010dk\xfd k\u016f\u0148 \xfap\u011bl \u010f\xe1belsk\xe9 \xf3dy z\xe1ke\u0159n\xfd u\u010de\u0148 b\u011b\u017e\xed pod\xe9l z\xf3ny \xfal\u016f"
words_nfd = u"Pr\u030ci\u0301s\u030cerne\u030c z\u030clut\u030couc\u030cky\u0301 ku\u030an\u030c u\u0301pe\u030cl d\u030ca\u0301belske\u0301 o\u0301dy za\u0301ker\u030cny\u0301 uc\u030cen\u030c be\u030cz\u030ci\u0301 pode\u0301l zo\u0301ny u\u0301lu\u030a"
passphrase_nfkd = (
u"Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko"
)
passphrase_nfc = (
u"Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko"
)
passphrase_nfkc = (
u"Neuv\u011b\u0159iteln\u011b bezpe\u010dn\xe9 hesl\xed\u010dko"
)
passphrase_nfd = (
u"Neuve\u030cr\u030citelne\u030c bezpec\u030cne\u0301 hesli\u0301c\u030cko"
)
device.wipe(self.client)
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=words_nfkd,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
self.client.set_passphrase(passphrase_nfkd)
address_nfkd = btc.get_address(self.client, "Bitcoin", [])
device.wipe(self.client)
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=words_nfc,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
self.client.set_passphrase(passphrase_nfc)
address_nfc = btc.get_address(self.client, "Bitcoin", [])
device.wipe(self.client)
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=words_nfkc,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
self.client.set_passphrase(passphrase_nfkc)
address_nfkc = btc.get_address(self.client, "Bitcoin", [])
device.wipe(self.client)
debuglink.load_device_by_mnemonic(
self.client,
mnemonic=words_nfd,
pin="",
passphrase_protection=True,
label="test",
language="english",
skip_checksum=True,
)
self.client.set_passphrase(passphrase_nfd)
address_nfd = btc.get_address(self.client, "Bitcoin", [])
assert address_nfkd == address_nfc
assert address_nfkd == address_nfkc
assert address_nfkd == address_nfd
def trezor_test_suite(emulator, rpc, userpass):
# Start the Trezor emulator
emulator_proc = subprocess.Popen([emulator])
# Wait for emulator to be up
# From https://github.com/trezor/trezor-mcu/blob/master/script/wait_for_emulator.py
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.connect(('127.0.0.1', 21324))
sock.settimeout(0)
while True:
try:
sock.sendall(b"PINGPING")
r = sock.recv(8)
if r == b"PONGPONG":
break
except Exception:
time.sleep(0.05)
# Cleanup
def cleanup_emulator():
emulator_proc.kill()
atexit.register(cleanup_emulator)
# Setup the emulator
for dev in enumerate_devices():
# Find the udp transport, that's the emulator
if isinstance(dev, UdpTransport):
wirelink = dev
break
client = TrezorClientDebugLink(wirelink)
device.wipe(client)
load_device_by_mnemonic(
client=client,
mnemonic=
'alcohol woman abuse must during monitor noble actual mixed trade anger aisle',
pin='',
passphrase_protection=False,
label='test') # From Trezor device tests
class TrezorTestCase(unittest.TestCase):
def __init__(self, client, methodName='runTest'):
super(TrezorTestCase, self).__init__(methodName)
self.client = client
@staticmethod
def parameterize(testclass, client):
testloader = unittest.TestLoader()
testnames = testloader.getTestCaseNames(testclass)
suite = unittest.TestSuite()
for name in testnames:
suite.addTest(testclass(client, name))
return suite
# Trezor specific getxpub test because this requires device specific thing to set xprvs
class TestTrezorGetxpub(TrezorTestCase):
def test_getxpub(self):
with open(os.path.join(os.path.dirname(os.path.realpath(__file__)),
'data/bip32_vectors.json'),
encoding='utf-8') as f:
vectors = json.load(f)
for vec in vectors:
with self.subTest(vector=vec):
# Setup with xprv
device.wipe(self.client)
load_device_by_xprv(client=self.client,
xprv=vec['xprv'],
pin='',
passphrase_protection=False,
label='test',
language='english')
# Test getmasterxpub
gmxp_res = process_commands([
'-t', 'trezor', '-d', 'udp:127.0.0.1:21324',
'getmasterxpub'
])
self.assertEqual(gmxp_res['xpub'], vec['master_xpub'])
# Test the path derivs
for path_vec in vec['vectors']:
gxp_res = process_commands([
'-t', 'trezor', '-d', 'udp:127.0.0.1:21324',
'getxpub', path_vec['path']
])
self.assertEqual(gxp_res['xpub'], path_vec['xpub'])
# Generic Device tests
suite = unittest.TestSuite()
suite.addTest(
DeviceTestCase.parameterize(
TestDeviceConnect, rpc, userpass, 'trezor', 'udp:127.0.0.1:21324',
'95d8f670',
'xpub6D1weXBcFAo8CqBbpP4TbH5sxQH8ZkqC5pDEvJ95rNNBZC9zrKmZP2fXMuve7ZRBe18pWQQsGg68jkq24mZchHwYENd8cCiSb71u3KD4AFH'
))
suite.addTest(
DeviceTestCase.parameterize(
TestGetKeypool, rpc, userpass, 'trezor', 'udp:127.0.0.1:21324',
'95d8f670',
'xpub6D1weXBcFAo8CqBbpP4TbH5sxQH8ZkqC5pDEvJ95rNNBZC9zrKmZP2fXMuve7ZRBe18pWQQsGg68jkq24mZchHwYENd8cCiSb71u3KD4AFH'
))
suite.addTest(
DeviceTestCase.parameterize(
TestSignTx, rpc, userpass, 'trezor', 'udp:127.0.0.1:21324',
'95d8f670',
'xpub6D1weXBcFAo8CqBbpP4TbH5sxQH8ZkqC5pDEvJ95rNNBZC9zrKmZP2fXMuve7ZRBe18pWQQsGg68jkq24mZchHwYENd8cCiSb71u3KD4AFH'
))
suite.addTest(
DeviceTestCase.parameterize(
TestDisplayAddress, rpc, userpass, 'trezor', 'udp:127.0.0.1:21324',
'95d8f670',
'xpub6D1weXBcFAo8CqBbpP4TbH5sxQH8ZkqC5pDEvJ95rNNBZC9zrKmZP2fXMuve7ZRBe18pWQQsGg68jkq24mZchHwYENd8cCiSb71u3KD4AFH'
))
suite.addTest(TrezorTestCase.parameterize(TestTrezorGetxpub, client))
return suite
