arno
/
trezor-firmware
mirror of https://github.com/trezor/trezor-firmware.git
1
0
Fork 0
Code Issues Releases Wiki Activity

chore(core/tests): update unit tests for new APIs, drop unnecessary ones

Browse Source
pull/1328/head
matejcik 4 years ago committed by matejcik
parent 5a97a5111b
commit eadf8ab25f
24 changed files with 241 additions and 484 deletions
Show Stats Download Patch File Download Diff File

30
core/tests/test_apps.binance.address.py
Unescape View File

@ -4,7 +4,7 @@ from apps.common.paths import HARDENED
from trezor.crypto.curve import secp256k1
if not utils.BITCOIN_ONLY:
from apps.binance.helpers import address_from_public_key, validate_full_path
from apps.binance.helpers import address_from_public_key
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -20,33 +20,5 @@ class TestBinanceAddress(unittest.TestCase):
self.assertEqual(address, expected_address)
def test_paths(self):
# 44'/714'/a'/0/0 is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 714 | HARDENED],
[44 | HARDENED, 714 | HARDENED, 0],
[44 | HARDENED, 714 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 714 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 714 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 714 | HARDENED, 0 | HARDENED, 0, 5],
[44 | HARDENED, 714 | HARDENED, 9999 | HARDENED],
[44 | HARDENED, 714 | HARDENED, 9999000 | HARDENED, 0, 0],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 714 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 714 | HARDENED, 3 | HARDENED, 0, 0],
[44 | HARDENED, 714 | HARDENED, 9 | HARDENED, 0, 0],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

132
core/tests/test_apps.bitcoin.address.py
Unescape View File

@ -1,12 +1,12 @@
from common import *
from trezor.crypto import bip32, bip39
from trezor.messages.GetAddress import GetAddress
from trezor.utils import HashWriter
from apps.bitcoin.addresses import validate_full_path
from apps.common.paths import HARDENED
from apps.common import coins
from apps.bitcoin import scripts
from apps.bitcoin.addresses import *
from apps.bitcoin.keychain import validate_path_against_script_type
from apps.bitcoin.writers import *
@ -32,17 +32,17 @@ class TestAddress(unittest.TestCase):
seed = bip39.seed(' '.join(['all'] * 12), '')
root = bip32.from_seed(seed, 'secp256k1')
node = node_derive(root, [49 | 0x80000000, 1 | 0x80000000, 0 | 0x80000000, 1, 0])
node = node_derive(root, [H_(49), H_(1), H_(0), 1, 0])
address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX')
node = node_derive(root, [49 | 0x80000000, 1 | 0x80000000, 0 | 0x80000000, 1, 1])
node = node_derive(root, [H_(49), H_(1), H_(0), 1, 1])
address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2NFWLCJQBSpz1oUJwwLpX8ECifFWGznBVqs')
node = node_derive(root, [49 | 0x80000000, 1 | 0x80000000, 0 | 0x80000000, 0, 0])
node = node_derive(root, [H_(49), H_(1), H_(0), 0, 0])
address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2N4Q5FhU2497BryFfUgbqkAJE87aKHUhXMp')
@ -129,96 +129,102 @@ class TestAddress(unittest.TestCase):
# def test_multisig_address_p2wsh(self):
# todo couldn't find test data
def validate(self, address_n, coin, script_type):
msg = GetAddress(address_n=address_n, script_type=script_type)
if script_type == InputScriptType.SPENDMULTISIG:
msg.multisig = True
return validate_path_against_script_type(coin, msg)
def test_paths_btc(self):
incorrect_derivation_paths = [
([49 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # too many HARDENED
([49 | HARDENED, 0 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 123 | HARDENED, 0 | HARDENED, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid slip44
([49 | HARDENED, 0 | HARDENED, 1000 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), # account too high
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 2, 0], InputScriptType.SPENDP2SHWITNESS), # invalid y
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDP2SHWITNESS), # address index too high
([84 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), # invalid input type
([84 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid input type
([49 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG), # invalid input type
([H_(49)], InputScriptType.SPENDP2SHWITNESS), # invalid length
([H_(49), H_(0), H_(0), H_(0), H_(0)], InputScriptType.SPENDP2SHWITNESS), # too many HARDENED
([H_(49), H_(0)], InputScriptType.SPENDP2SHWITNESS), # invalid length
([H_(49), H_(0), H_(0), 0, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid length
([H_(49), H_(123), H_(0), 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid slip44
([H_(49), H_(0), H_(1000), 0, 0], InputScriptType.SPENDP2SHWITNESS), # account too high
([H_(49), H_(0), H_(1), 2, 0], InputScriptType.SPENDP2SHWITNESS), # invalid y
([H_(49), H_(0), H_(1), 0, 10000000], InputScriptType.SPENDP2SHWITNESS), # address index too high
([H_(84), H_(0), H_(1), 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([H_(49), H_(0), H_(1), 0, 0], InputScriptType.SPENDWITNESS), # invalid input type
([H_(84), H_(0), H_(1), 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid input type
([H_(49), H_(0), H_(5), 0, 10], InputScriptType.SPENDMULTISIG), # invalid input type
]
correct_derivation_paths = [
([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), # btc is segwit coin, but non-segwit paths are allowed as well
([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 1], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS),
([84 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS),
([84 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS),
([84 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDWITNESS),
([48 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG),
([H_(44), H_(0), H_(0), 0, 0], InputScriptType.SPENDADDRESS), # btc is segwit coin, but non-segwit paths are allowed as well
([H_(44), H_(0), H_(0), 0, 1], InputScriptType.SPENDADDRESS),
([H_(44), H_(0), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([H_(49), H_(0), H_(0), 0, 0], InputScriptType.SPENDP2SHWITNESS),
([H_(49), H_(0), H_(0), 1, 0], InputScriptType.SPENDP2SHWITNESS),
([H_(49), H_(0), H_(0), 0, 1123], InputScriptType.SPENDP2SHWITNESS),
([H_(49), H_(0), H_(0), 1, 44444], InputScriptType.SPENDP2SHWITNESS),
([H_(49), H_(0), H_(5), 0, 0], InputScriptType.SPENDP2SHWITNESS),
([H_(84), H_(0), H_(0), 0, 0], InputScriptType.SPENDWITNESS),
([H_(84), H_(0), H_(5), 0, 0], InputScriptType.SPENDWITNESS),
([H_(84), H_(0), H_(5), 0, 10], InputScriptType.SPENDWITNESS),
([H_(48), H_(0), H_(5), H_(0), 0, 10], InputScriptType.SPENDMULTISIG),
]
coin = coins.by_name('Bitcoin')
for path, input_type in incorrect_derivation_paths:
self.assertFalse(validate_full_path(path, coin, input_type))
self.assertFalse(self.validate(path, coin, input_type))
for path, input_type in correct_derivation_paths:
self.assertTrue(validate_full_path(path, coin, input_type))
self.assertTrue(self.validate(path, coin, input_type))
self.assertTrue(validate_full_path([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], coin, InputScriptType.SPENDADDRESS))
self.assertFalse(validate_full_path([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], coin, InputScriptType.SPENDWITNESS))
self.assertTrue(validate_full_path([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], coin, InputScriptType.SPENDWITNESS, validate_script_type=False))
self.assertTrue(self.validate([H_(44), H_(0), H_(0), 0, 0], coin, InputScriptType.SPENDADDRESS))
self.assertFalse(self.validate([H_(44), H_(0), H_(0), 0, 0], coin, InputScriptType.SPENDWITNESS))
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
def test_paths_bch(self):
incorrect_derivation_paths = [
([44 | HARDENED], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], InputScriptType.SPENDADDRESS), # too many HARDENED
([49 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), # bch is not segwit coin so 49' is not allowed
([84 | HARDENED, 145 | HARDENED, 1 | HARDENED, 0, 1], InputScriptType.SPENDWITNESS), # and neither is 84'
([44 | HARDENED, 145 | HARDENED], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 123 | HARDENED, 0 | HARDENED, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid slip44
([44 | HARDENED, 145 | HARDENED, 1000 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), # account too high
([44 | HARDENED, 145 | HARDENED, 1 | HARDENED, 2, 0], InputScriptType.SPENDADDRESS), # invalid y
([44 | HARDENED, 145 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDADDRESS), # address index too high
([84 | HARDENED, 145 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), # input type mismatch
([H_(44)], InputScriptType.SPENDADDRESS), # invalid length
([H_(44), H_(145), H_(0), H_(0), H_(0)], InputScriptType.SPENDADDRESS), # too many HARDENED
([H_(49), H_(145), H_(0), 0, 0], InputScriptType.SPENDP2SHWITNESS), # bch is not segwit coin so 49' is not allowed
([H_(84), H_(145), H_(1), 0, 1], InputScriptType.SPENDWITNESS), # and neither is 84'
([H_(44), H_(145)], InputScriptType.SPENDADDRESS), # invalid length
([H_(44), H_(145), H_(0), 0, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid length
([H_(44), H_(123), H_(0), 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid slip44
([H_(44), H_(145), H_(1000), 0, 0], InputScriptType.SPENDADDRESS), # account too high
([H_(44), H_(145), H_(1), 2, 0], InputScriptType.SPENDADDRESS), # invalid y
([H_(44), H_(145), H_(1), 0, 10000000], InputScriptType.SPENDADDRESS), # address index too high
([H_(84), H_(145), H_(1), 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([H_(44), H_(145), H_(0), 0, 0], InputScriptType.SPENDWITNESS), # input type mismatch
]
correct_derivation_paths = [
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS),
([48 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDMULTISIG),
([48 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDMULTISIG),
([48 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG),
([H_(44), H_(145), H_(0), 0, 0], InputScriptType.SPENDADDRESS),
([H_(44), H_(145), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([H_(44), H_(145), H_(0), 0, 1123], InputScriptType.SPENDADDRESS),
([H_(44), H_(145), H_(0), 1, 44444], InputScriptType.SPENDADDRESS),
([H_(44), H_(145), H_(5), 0, 0], InputScriptType.SPENDADDRESS),
([H_(48), H_(145), H_(0), H_(0), 0, 0], InputScriptType.SPENDMULTISIG),
([H_(48), H_(145), H_(5), H_(0), 0, 0], InputScriptType.SPENDMULTISIG),
([H_(48), H_(145), H_(5), H_(0), 0, 10], InputScriptType.SPENDMULTISIG),
]
coin = coins.by_name('Bcash') # segwit is disabled
for path, input_type in incorrect_derivation_paths:
self.assertFalse(validate_full_path(path, coin, input_type))
self.assertFalse(self.validate(path, coin, input_type))
for path, input_type in correct_derivation_paths:
self.assertTrue(validate_full_path(path, coin, input_type))
self.assertTrue(self.validate(path, coin, input_type))
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
def test_paths_other(self):
incorrect_derivation_paths = [
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDMULTISIG), # input type mismatch
([H_(44), H_(3), H_(0), 0, 0], InputScriptType.SPENDMULTISIG), # input type mismatch
]
correct_derivation_paths = [
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDADDRESS),
([H_(44), H_(3), H_(0), 0, 0], InputScriptType.SPENDADDRESS),
([H_(44), H_(3), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([H_(44), H_(3), H_(0), 0, 1123], InputScriptType.SPENDADDRESS),
([H_(44), H_(3), H_(0), 1, 44444], InputScriptType.SPENDADDRESS),
]
coin = coins.by_name('Dogecoin') # segwit is disabled
for path, input_type in correct_derivation_paths:
self.assertTrue(validate_full_path(path, coin, input_type))
self.assertTrue(self.validate(path, coin, input_type))
for path, input_type in incorrect_derivation_paths:
self.assertFalse(validate_full_path(path, coin, input_type))
self.assertFalse(self.validate(path, coin, input_type))
if __name__ == '__main__':

106
core/tests/test_apps.wallet.keychain.py → core/tests/test_apps.bitcoin.keychain.py
Unescape View File

@ -20,15 +20,23 @@ class TestBitcoinKeychain(unittest.TestCase):
self.assertEqual(coin.coin_name, "Bitcoin")
valid_addresses = (
[44 | HARDENED, 0 | HARDENED],
[45 | HARDENED, 123456],
[48 | HARDENED, 0 | HARDENED],
[49 | HARDENED, 0 | HARDENED],
[84 | HARDENED, 0 | HARDENED],
[H_(44), H_(0), H_(0), 0, 0],
[H_(45), 99, 1, 1000],
[H_(48), H_(0), H_(0), H_(2), 1, 1000],
[H_(49), H_(0), H_(0), 0, 10],
[H_(84), H_(0), H_(0), 0, 10],
# Casa:
[49, 0, 0, 0, 10],
# Green:
[1, 1000],
[H_(3), H_(10), 4, 1000],
)
invalid_addresses = (
[43 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 1 | HARDENED],
[H_(43), H_(0), H_(0), 0, 0],
[H_(44), H_(1), H_(0), 0, 0],
[44, 0, 0, 0, 0],
[H_(44), H_(0), H_(0)],
[H_(44), H_(0), H_(0), 0, 0, 0],
)
for addr in valid_addresses:
@ -44,15 +52,23 @@ class TestBitcoinKeychain(unittest.TestCase):
self.assertEqual(coin.coin_name, "Testnet")
valid_addresses = (
[44 | HARDENED, 1 | HARDENED],
[45 | HARDENED, 123456],
[48 | HARDENED, 1 | HARDENED],
[49 | HARDENED, 1 | HARDENED],
[84 | HARDENED, 1 | HARDENED],
[H_(44), H_(1), H_(0), 0, 0],
[H_(45), 99, 1, 1000],
[H_(48), H_(1), H_(0), H_(2), 1, 1000],
[H_(49), H_(1), H_(0), 0, 10],
[H_(84), H_(1), H_(0), 0, 10],
# Casa:
[49, 1, 0, 0, 10],
# Green:
[1, 1000],
[H_(3), H_(10), 4, 1000],
)
invalid_addresses = (
[43 | HARDENED, 1 | HARDENED],
[44 | HARDENED, 0 | HARDENED],
[H_(43), H_(1), H_(0), 0, 0],
[H_(44), H_(0), H_(0), 0, 0],
[44, 1, 0, 0, 0],
[H_(44), H_(1), H_(0)],
[H_(44), H_(1), H_(0), 0, 0, 0],
)
for addr in valid_addresses:
@ -64,7 +80,7 @@ class TestBitcoinKeychain(unittest.TestCase):
def test_unspecified(self):
keychain, coin = await_result(get_keychain_for_coin(wire.DUMMY_CONTEXT, None))
self.assertEqual(coin.coin_name, "Bitcoin")
keychain.derive([44 | HARDENED, 0 | HARDENED])
keychain.derive([H_(44), H_(0), H_(0), 0, 0])
def test_unknown(self):
with self.assertRaises(wire.DataError):
@ -85,20 +101,29 @@ class TestAltcoinKeychains(unittest.TestCase):
self.assertEqual(coin.coin_name, "Bcash")
self.assertFalse(coin.segwit)
self.assertIsNotNone(coin.fork_id)
valid_addresses = (
[44 | HARDENED, 145 | HARDENED],
[44 | HARDENED, 0 | HARDENED],
[45 | HARDENED, 123456],
[48 | HARDENED, 145 | HARDENED],
[48 | HARDENED, 0 | HARDENED],
[H_(44), H_(145), H_(0), 0, 0],
# Bitcoin paths should be allowed, as Bcash has strong replay protection
[H_(44), H_(0), H_(0), 0, 0],
[H_(45), 99, 1, 1000],
[H_(48), H_(145), H_(0), H_(0), 1, 1000],
[H_(48), H_(0), H_(0), H_(0), 1, 1000],
)
invalid_addresses = (
[43 | HARDENED, 145 | HARDENED],
[43 | HARDENED, 0 | HARDENED],
[49 | HARDENED, 145 | HARDENED],
[49 | HARDENED, 0 | HARDENED],
[84 | HARDENED, 145 | HARDENED],
[84 | HARDENED, 0 | HARDENED],
[H_(43), H_(145), H_(0), 0, 0],
[44, 145, 0, 0, 0],
[H_(44), H_(145), H_(0)],
[H_(44), H_(145), H_(0), 0, 0, 0],
# segwit:
[H_(49), H_(145), H_(0), 0, 10],
[H_(84), H_(145), H_(0), 0, 10],
# Casa:
[49, 145, 0, 0, 10],
# Green:
[1, 1000],
[H_(3), 10, 4, 1000],
)
for addr in valid_addresses:
@ -115,18 +140,27 @@ class TestAltcoinKeychains(unittest.TestCase):
self.assertTrue(coin.segwit)
valid_addresses = (
[44 | HARDENED, 2 | HARDENED],
[45 | HARDENED, 123456],
[48 | HARDENED, 2 | HARDENED],
[49 | HARDENED, 2 | HARDENED],
[84 | HARDENED, 2 | HARDENED],
[H_(44), H_(2), H_(0), 0, 0],
[H_(45), 99, 1, 1000],
[H_(48), H_(2), H_(0), H_(2), 1, 1000],
[H_(49), H_(2), H_(0), 0, 10],
[H_(84), H_(2), H_(0), 0, 10],
)
invalid_addresses = (
[43 | HARDENED, 2 | HARDENED],
[44 | HARDENED, 0 | HARDENED],
[48 | HARDENED, 0 | HARDENED],
[49 | HARDENED, 0 | HARDENED],
[84 | HARDENED, 0 | HARDENED],
[H_(43), H_(2), H_(0), 0, 0],
# Bitcoin paths:
[H_(44), H_(0), H_(0), 0, 0],
[H_(49), H_(0), H_(0), 0, 0],
[H_(84), H_(0), H_(0), 0, 0],
[44, 2, 0, 0, 0],
[H_(44), H_(2), H_(0)],
[H_(44), H_(2), H_(0), 0, 0, 0],
# Casa:
[49, 2, 0, 0, 10],
# Green:
[1, 1000],
[H_(3), 10, 4, 1000],
)
for addr in valid_addresses:

16
core/tests/test_apps.bitcoin.ownership_proof.py
Unescape View File

@ -6,7 +6,7 @@ from trezor.messages.HDNodeType import HDNodeType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.common.paths import HARDENED
from apps.common.paths import HARDENED, AlwaysMatchingSchema
from apps.bitcoin import ownership, scripts
from apps.bitcoin.addresses import address_p2wpkh, address_p2wpkh_in_p2sh, address_multisig_p2wsh, address_multisig_p2wsh_in_p2sh, address_multisig_p2sh
from apps.bitcoin.multisig import multisig_get_pubkeys
@ -17,7 +17,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wpkh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '')
keychain = Keychain(seed, coin.curve_name, [[84 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b""
node = keychain.derive([84 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0])
@ -43,7 +43,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wpkh_in_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '')
keychain = Keychain(seed, coin.curve_name, [[49 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b""
node = keychain.derive([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0])
@ -70,7 +70,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2pkh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), 'TREZOR')
keychain = Keychain(seed, coin.curve_name, [[44 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b""
node = keychain.derive([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0])
@ -96,7 +96,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wpkh_verify_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), 'TREZOR')
keychain = Keychain(seed, coin.curve_name, [], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b""
# Proof for "all all ... all" seed without passphrase.
@ -107,7 +107,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wsh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '')
keychain = Keychain(seed, coin.curve_name, [[84 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b"TREZOR"
nodes = []
@ -167,7 +167,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wsh_in_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '')
keychain = Keychain(seed, coin.curve_name, [[49 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b""
nodes = []
@ -241,7 +241,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '')
keychain = Keychain(seed, coin.curve_name, [[48 | HARDENED]], [[b"SLIP-0019"]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema], slip21_namespaces=[[b"SLIP-0019"]])
commitment_data = b"TREZOR"
nodes = []

3
core/tests/test_apps.bitcoin.segwit.bip143.native_p2wpkh.py
Unescape View File

@ -6,6 +6,7 @@ from apps.bitcoin.sign_tx.bitcoin import Hash143
from apps.bitcoin.writers import get_tx_hash
from apps.common import coins
from apps.common.keychain import Keychain
from apps.common.paths import AlwaysMatchingSchema
from trezor.messages.SignTx import SignTx
from trezor.messages.TxInput import TxInput
from trezor.messages.TxOutput import TxOutput
@ -89,7 +90,7 @@ class TestSegwitBip143NativeP2WPKH(unittest.TestCase):
txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey)
bip143.add_output(txo_bin, script_pubkey)
keychain = Keychain(seed, coin.curve_name, [[]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema])
node = keychain.derive(self.inp2.address_n)
# test data public key hash

3
core/tests/test_apps.bitcoin.segwit.bip143.p2wpkh_in_p2sh.py
Unescape View File

@ -6,6 +6,7 @@ from apps.bitcoin.sign_tx.bitcoin import Hash143
from apps.bitcoin.writers import get_tx_hash
from apps.common import coins
from apps.common.keychain import Keychain
from apps.common.paths import AlwaysMatchingSchema
from trezor.messages.SignTx import SignTx
from trezor.messages.TxInput import TxInput
from trezor.messages.TxOutput import TxOutput
@ -75,7 +76,7 @@ class TestSegwitBip143(unittest.TestCase):
txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey)
bip143.add_output(txo_bin, script_pubkey)
keychain = Keychain(seed, coin.curve_name, [[]])
keychain = Keychain(seed, coin.curve_name, [AlwaysMatchingSchema])
node = keychain.derive(self.inp1.address_n)
# test data public key hash

8
core/tests/test_apps.bitcoin.segwit.signtx.native_p2wpkh.py
Unescape View File

@ -27,7 +27,7 @@ from trezor import wire
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import helpers, bitcoin
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -157,7 +157,7 @@ class TestSignSegwitTxNativeP2WPKH(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()
@ -286,7 +286,7 @@ class TestSignSegwitTxNativeP2WPKH(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()
@ -347,7 +347,7 @@ class TestSignSegwitTxNativeP2WPKH(unittest.TestCase):
None
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()

6
core/tests/test_apps.bitcoin.segwit.signtx.native_p2wpkh_grs.py
Unescape View File

@ -26,7 +26,7 @@ from trezor.messages import OutputScriptType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -158,7 +158,7 @@ class TestSignSegwitTxNativeP2WPKH_GRS(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer()
@ -287,7 +287,7 @@ class TestSignSegwitTxNativeP2WPKH_GRS(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer()

8
core/tests/test_apps.bitcoin.segwit.signtx.p2wpkh_in_p2sh.py
Unescape View File

@ -27,7 +27,7 @@ from trezor import wire
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -154,7 +154,7 @@ class TestSignSegwitTxP2WPKHInP2SH(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()
@ -291,7 +291,7 @@ class TestSignSegwitTxP2WPKHInP2SH(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()
@ -398,7 +398,7 @@ class TestSignSegwitTxP2WPKHInP2SH(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()

6
core/tests/test_apps.bitcoin.segwit.signtx.p2wpkh_in_p2sh_grs.py
Unescape View File

@ -26,7 +26,7 @@ from trezor.messages import OutputScriptType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -158,7 +158,7 @@ class TestSignSegwitTxP2WPKHInP2SH_GRS(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer()
@ -295,7 +295,7 @@ class TestSignSegwitTxP2WPKHInP2SH_GRS(unittest.TestCase):
)),
]
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer()

3
core/tests/test_apps.bitcoin.signtx.fee_threshold.py
Unescape View File

@ -25,6 +25,7 @@ from trezor.messages import OutputScriptType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.common.paths import AlwaysMatchingSchema
from apps.bitcoin.sign_tx import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -161,7 +162,7 @@ class TestSignTxFeeThreshold(unittest.TestCase):
seed = bip39.seed('alcohol woman abuse must during monitor noble actual mixed trade anger aisle', '')
keychain = Keychain(seed, coin_bitcoin.curve_name, [[]])
keychain = Keychain(seed, coin_bitcoin.curve_name, [AlwaysMatchingSchema])
approver = BasicApprover(tx, coin_bitcoin)
signer = bitcoin.Bitcoin(tx, keychain, coin_bitcoin, approver).signer()
for request, response in chunks(messages, 2):

4
core/tests/test_apps.bitcoin.signtx.py
Unescape View File

@ -25,7 +25,7 @@ from trezor.messages import OutputScriptType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -107,7 +107,7 @@ class TestSignTx(unittest.TestCase):
]
seed = bip39.seed('alcohol woman abuse must during monitor noble actual mixed trade anger aisle', '')
ns = get_namespaces_for_coin(coin_bitcoin)
ns = get_schemas_for_coin(coin_bitcoin)
keychain = Keychain(seed, coin_bitcoin.curve_name, ns)
approver = BasicApprover(tx, coin_bitcoin)
signer = bitcoin.Bitcoin(tx, keychain, coin_bitcoin, approver).signer()

4
core/tests/test_apps.bitcoin.signtx_grs.py
Unescape View File

@ -25,7 +25,7 @@ from trezor.messages import OutputScriptType
from apps.common import coins
from apps.common.keychain import Keychain
from apps.bitcoin.keychain import get_namespaces_for_coin
from apps.bitcoin.keychain import get_schemas_for_coin
from apps.bitcoin.sign_tx import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -101,7 +101,7 @@ class TestSignTx_GRS(unittest.TestCase):
]
seed = bip39.seed(' '.join(['all'] * 12), '')
ns = get_namespaces_for_coin(coin)
ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer()

37
core/tests/test_apps.cardano.address.py
Unescape View File

@ -8,14 +8,8 @@ from trezor.messages.CardanoBlockchainPointerType import CardanoBlockchainPointe
from apps.common import HARDENED, seed
if not utils.BITCOIN_ONLY:
from apps.cardano.address import (
derive_human_readable_address,
validate_full_path,
)
from apps.cardano.byron_address import (
_get_address_root,
_address_hash,
)
from apps.cardano.address import derive_human_readable_address
from apps.cardano.byron_address import _address_hash
from apps.cardano.helpers import network_ids, protocol_magics
from apps.cardano.seed import Keychain
@ -156,33 +150,6 @@ class TestCardanoAddress(unittest.TestCase):
self.assertEqual(result, b'\x1c\xca\xee\xc9\x80\xaf}\xb0\x9a\xa8\x96E\xd6\xa4\xd1\xb4\x13\x85\xb9\xc2q\x1d5/{\x12"\xca')
def test_paths(self):
incorrect_derivation_paths = [
[HARDENED | 44],
[HARDENED | 44, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815],
[HARDENED | 43, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815],
[HARDENED | 44, HARDENED | 1816, HARDENED | 1815, HARDENED | 1815, HARDENED | 1815],
[HARDENED | 44, HARDENED | 1815, 0],
[HARDENED | 44, HARDENED | 1815, 0, 0],
[HARDENED | 44, HARDENED | 1815],
[HARDENED | 44, HARDENED | 1815, HARDENED | 0],
[HARDENED | 44, HARDENED | 1815, HARDENED | 1815, 1, 1],
[HARDENED | 44, HARDENED | 1815, HARDENED | 1815, 0, 0], # a too large
]
correct_derivation_paths = [
[HARDENED | 44, HARDENED | 1815, HARDENED | 0, 0, 1],
[HARDENED | 44, HARDENED | 1815, HARDENED | 9, 0, 4],
[HARDENED | 44, HARDENED | 1815, HARDENED | 0, 0, 9],
[HARDENED | 44, HARDENED | 1815, HARDENED | 0, 1, 1],
[HARDENED | 44, HARDENED | 1815, HARDENED | 0, 1, 9],
]
for path in incorrect_derivation_paths:
self.assertFalse(validate_full_path(path))
for path in correct_derivation_paths:
self.assertTrue(validate_full_path(path))
def test_slip39_128(self):
mnemonics = [
"extra extend academic bishop cricket bundle tofu goat apart victim "

6
core/tests/test_apps.common.paths.py
Unescape View File

@ -43,7 +43,7 @@ class TestPathSchemas(unittest.TestCase):
def is_equal(a, b):
if isinstance(a, range) and isinstance(b, range):
return a.start == b.start and a.step == b.step and a.stop == b.stop
return a == b
return set(a) == set(b)
ensure(
all(is_equal(a, b) for a, b in zip(schema_a.schema, schema_b.schema))
@ -63,8 +63,8 @@ class TestPathSchemas(unittest.TestCase):
[H_(44), H_(0), H_(0), H_(0), H_(0)] * 10,
]
for path in paths:
self.assertMatch(SCHEMA_ANY_PATH, path)
self.assertMismatch(SCHEMA_NO_MATCH, path)
self.assertMatch(AlwaysMatchingSchema, path)
self.assertMismatch(NeverMatchingSchema, path)
def test_pattern_fixed(self):
pattern = "m/44'/0'/0'/0/0"

27
core/tests/test_apps.eos.get_public_key.py
Unescape View File

@ -5,7 +5,7 @@ from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.eos.get_public_key import _get_public_key
from apps.eos.helpers import validate_full_path, public_key_to_wif
from apps.eos.helpers import public_key_to_wif
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -44,31 +44,6 @@ class TestEosGetPublicKey(unittest.TestCase):
self.assertEqual(wif, wif_keys[index])
self.assertEqual(public_key_to_wif(public_key), wif_keys[index])
def test_paths(self):
# 44'/194'/a'/0/0 is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 194 | HARDENED],
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 0, 0, 0],
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 0, 1],
[44 | HARDENED, 160 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 199 | HARDENED, 0 | HARDENED, 0, 9999],
]
correct_paths = [
[44 | HARDENED, 194 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 194 | HARDENED, 9 | HARDENED, 0, 0],
[44 | HARDENED, 194 | HARDENED, 9999 | HARDENED, 0, 0],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

32
core/tests/test_apps.ethereum.address.py
Unescape View File

@ -2,8 +2,8 @@ from common import *
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.ethereum.address import address_from_bytes, bytes_from_address, validate_full_path
from apps.ethereum.networks import NetworkInfo, by_chain_id
from apps.ethereum.address import address_from_bytes
from apps.ethereum.networks import NetworkInfo
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -54,34 +54,6 @@ class TestEthereumGetAddress(unittest.TestCase):
h = address_from_bytes(b, n)
self.assertEqual(h, '0x' + s)
def test_paths(self):
# 44'/60'/0'/0/i is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 60 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0, 0],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 60 | HARDENED, 1 | HARDENED, 0, 0],
[44 | HARDENED, 160 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 199 | HARDENED, 0 | HARDENED, 0, 9999], # slip44 not one of ETH chains
]
correct_paths = [
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 9],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 9999],
[44 | HARDENED, 6060 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 1 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 5718350 | HARDENED, 0 | HARDENED, 0, 0],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

64
core/tests/test_apps.ethereum.keychain.py
Unescape View File

@ -2,11 +2,14 @@ from common import *
from storage import cache
from trezor import wire
from trezor.crypto import bip39
from apps.common.keychain import get_keychain
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.ethereum import CURVE
from apps.ethereum.keychain import (
from_address_n,
PATTERNS_ADDRESS,
_schemas_from_address_n,
with_keychain_from_path,
with_keychain_from_chain_id,
)
@ -21,19 +24,23 @@ class TestEthereumKeychain(unittest.TestCase):
def _check_keychain(self, keychain, slip44_id):
# valid address should succeed
valid_addresses = (
[44 | HARDENED, slip44_id | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 19 | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0, 999],
)
for addr in valid_addresses:
keychain.derive(addr)
# invalid address should fail
invalid_addresses = (
[44 | HARDENED],
[44 | HARDENED, 0 | HARDENED],
[42 | HARDENED, slip44_id | HARDENED],
[44 | HARDENED, slip44_id | HARDENED],
[44 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[42 | HARDENED, slip44_id | HARDENED, 0 | HARDENED],
[0 | HARDENED, slip44_id | HARDENED, 0 | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0 | HARDENED, 0],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
)
for addr in invalid_addresses:
self.assertRaises(
@ -45,35 +52,27 @@ class TestEthereumKeychain(unittest.TestCase):
seed = bip39.seed(" ".join(["all"] * 12), "")
cache.set(cache.APP_COMMON_SEED, seed)
def from_address_n(self, address_n):
schemas = _schemas_from_address_n(PATTERNS_ADDRESS, address_n)
return await_result(get_keychain(wire.DUMMY_CONTEXT, CURVE, schemas))
def test_from_address_n(self):
# valid keychain m/44'/60'/0'
keychain = await_result(
from_address_n(
wire.DUMMY_CONTEXT, [44 | HARDENED, 60 | HARDENED, 0 | HARDENED]
)
)
keychain = self.from_address_n([44 | HARDENED, 60 | HARDENED, 0 | HARDENED])
self._check_keychain(keychain, 60)
def test_from_address_n_unknown(self):
# try Bitcoin slip44 id m/44'/0'/0'
with self.assertRaises(wire.DataError):
await_result(
from_address_n(
wire.DUMMY_CONTEXT, [44 | HARDENED, 0 | HARDENED, 0 | HARDENED]
)
)
schemas = tuple(_schemas_from_address_n(PATTERNS_ADDRESS, [44 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
self.assertEqual(schemas, ())
def test_bad_address_n(self):
# keychain generated from valid slip44 id but invalid address m/0'/60'/0'
keychain = await_result(
from_address_n(
wire.DUMMY_CONTEXT, [0 | HARDENED, 60 | HARDENED, 0 | HARDENED]
)
)
keychain = self.from_address_n([0 | HARDENED, 60 | HARDENED, 0 | HARDENED])
self._check_keychain(keychain, 60)
def test_with_keychain_from_path(self):
@with_keychain_from_path
@with_keychain_from_path(*PATTERNS_ADDRESS)
async def handler(ctx, msg, keychain):
self._check_keychain(keychain, msg.address_n[1] & ~HARDENED)
@ -107,9 +106,9 @@ class TestEthereumKeychain(unittest.TestCase):
def test_with_keychain_from_chain_id(self):
@with_keychain_from_chain_id
async def handler_chain_id(ctx, msg, keychain):
network = by_chain_id(msg.chain_id)
slip44_id = msg.address_n[1] & ~HARDENED
# standard tests
self._check_keychain(keychain, network.slip44)
self._check_keychain(keychain, slip44_id)
# provided address should succeed too
keychain.derive(msg.address_n)
@ -133,6 +132,19 @@ class TestEthereumKeychain(unittest.TestCase):
)
)
# Known chain-ids are allowed to use Ethereum derivation paths too, as there is
# no risk of replaying the transaction on the Ethereum chain
await_result( # ETH slip44 with ETC chain-id
handler_chain_id(
wire.DUMMY_CONTEXT,
EthereumSignTx(
address_n=[44 | HARDENED, 60 | HARDENED, 0 | HARDENED],
chain_id=61,
),
)
)
with self.assertRaises(wire.DataError):
await_result( # unknown chain_id
handler_chain_id(
@ -149,7 +161,7 @@ class TestEthereumKeychain(unittest.TestCase):
handler_chain_id(
wire.DUMMY_CONTEXT,
EthereumSignTx(
address_n=[44 | HARDENED, 60 | HARDENED, 0 | HARDENED],
address_n=[44 | HARDENED, 61 | HARDENED, 0 | HARDENED],
chain_id=2,
),
)
@ -158,9 +170,9 @@ class TestEthereumKeychain(unittest.TestCase):
def test_missing_chain_id(self):
@with_keychain_from_chain_id
async def handler_chain_id(ctx, msg, keychain):
network = by_slip44(msg.address_n[1] & ~HARDENED)
slip44_id = msg.address_n[1] & ~HARDENED
# standard tests
self._check_keychain(keychain, network.slip44)
self._check_keychain(keychain, slip44_id)
# provided address should succeed too
keychain.derive(msg.address_n)

39
core/tests/test_apps.lisk.address.py
Unescape View File

@ -1,39 +0,0 @@
from common import *
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.lisk.helpers import validate_full_path
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
class TestLiskGetAddress(unittest.TestCase):
def test_paths(self):
# 44'/134'/a' is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 134 | HARDENED],
[44 | HARDENED, 134 | HARDENED, 0],
[44 | HARDENED, 134 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 134 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 134 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 134 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 134 | HARDENED, 9999000 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 134 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 134 | HARDENED, 3 | HARDENED],
[44 | HARDENED, 134 | HARDENED, 9 | HARDENED],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

39
core/tests/test_apps.monero.address.py
Unescape View File

@ -1,39 +0,0 @@
from common import *
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.monero.misc import validate_full_path
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
class TestMoneroGetAddress(unittest.TestCase):
def test_paths(self):
# 44'/128'/a' is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 128 | HARDENED],
[44 | HARDENED, 128 | HARDENED, 0],
[44 | HARDENED, 128 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 128 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 128 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 128 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 128 | HARDENED, 9999000 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 128 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 128 | HARDENED, 3 | HARDENED],
[44 | HARDENED, 128 | HARDENED, 9 | HARDENED],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

62
core/tests/test_apps.nem.address.py
Unescape View File

@ -3,7 +3,7 @@ from apps.common import HARDENED
if not utils.BITCOIN_ONLY:
from trezor.crypto import nem
from apps.nem.helpers import check_path, NEM_NETWORK_MAINNET, NEM_NETWORK_TESTNET
from apps.nem.helpers import check_path, NEM_NETWORK_MAINNET, NEM_NETWORK_TESTNET, NEM_NETWORK_MIJIN
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -35,46 +35,26 @@ class TestNemAddress(unittest.TestCase):
validity = nem.validate_address('NCUKWDY3J3THKQHAKOK5ALF6ANJQABZHCH7VN6DP', NEM_NETWORK_TESTNET)
self.assertFalse(validity)
def test_paths(self):
# 44'/43'/0'/0'/0'
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
# 44'/43'/0'/0'/0'
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
# 44'/1'/0'/0'/0' testnet
self.assertTrue(check_path([44 | HARDENED, 1 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0 | HARDENED], network=0x98))
# 44'/43'/0'
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED]))
# 44'/43'/2'
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 2 | HARDENED]))
# 44'/1'/0' testnet
self.assertTrue(check_path([44 | HARDENED, 1 | HARDENED, 0 | HARDENED], network=0x98))
# 44'/43'/0'/0'/1'
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1 | HARDENED]))
# 44'/43'/0'/1'/1'
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 1 | HARDENED, 1 | HARDENED]))
# 44'/43'/0'/1'/0'
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0 | HARDENED]))
# 44'/43'/99999'/0'/0'
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 99999000 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
# 44'/99'/0'/0'/0'
self.assertFalse(check_path([44 | HARDENED, 99 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
# 1'/43'/0'/0'/0'
self.assertFalse(check_path([1 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
# 44'/43'/0'/0/0
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0, 0]))
# 44'/43'/0'/0/5
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0, 5]))
# 44'/1'/3'/0'/1' testnet
self.assertFalse(check_path([44 | HARDENED, 1 | HARDENED, 3 | HARDENED, 0 | HARDENED, 1 | HARDENED], network=0x98))
# 44'/43'/0/0/1
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0, 0, 1]))
# 44'/43'/0/0/0
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0, 0, 0]))
# 44'/43'/0/0'/0'
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0, 0 | HARDENED, 0 | HARDENED]))
def test_check_path(self):
# mainnet path:
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_MAINNET))
# should be valid on mijin as well:
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_MIJIN))
# testnet path:
self.assertTrue(check_path([44 | HARDENED, 1 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_TESTNET))
# short path (check_path does not validate pattern match):
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED], NEM_NETWORK_MAINNET))
# testnet path on mainnet:
self.assertFalse(check_path([44 | HARDENED, 1 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_MAINNET))
# mainnet path on testnet:
self.assertFalse(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_TESTNET))
# path too short to extract SLIP44:
self.assertFalse(check_path([44 | HARDENED], NEM_NETWORK_TESTNET))
# unknown SLIP44:
self.assertFalse(check_path([44 | HARDENED, 0 | HARDENED], NEM_NETWORK_MAINNET))
# unhardened SLIP44:
self.assertFalse(check_path([44 | HARDENED, 43, 0], NEM_NETWORK_MAINNET))
if __name__ == '__main__':

30
core/tests/test_apps.ripple.address.py
Unescape View File

@ -1,8 +1,7 @@
from common import *
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.ripple.helpers import address_from_public_key, validate_full_path
from apps.ripple.helpers import address_from_public_key
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -18,33 +17,6 @@ class TestRippleAddress(unittest.TestCase):
addr = address_from_public_key(unhexlify('0282ee731039929e97db6aec242002e9aa62cd62b989136df231f4bb9b8b7c7eb2'))
self.assertEqual(addr, 'rKzE5DTyF9G6z7k7j27T2xEas2eMo85kmw')
def test_paths(self):
# 44'/144'/a'/0/0 is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 144 | HARDENED],
[44 | HARDENED, 144 | HARDENED, 0],
[44 | HARDENED, 144 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 144 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 144 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 144 | HARDENED, 0 | HARDENED, 0, 5],
[44 | HARDENED, 144 | HARDENED, 9999 | HARDENED],
[44 | HARDENED, 144 | HARDENED, 9999000 | HARDENED, 0, 0],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 144 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 144 | HARDENED, 3 | HARDENED, 0, 0],
[44 | HARDENED, 144 | HARDENED, 9 | HARDENED, 0, 0],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

29
core/tests/test_apps.stellar.address.py
Unescape View File

@ -1,9 +1,8 @@
from common import *
from apps.common.paths import HARDENED
from trezor.wire import ProcessError
if not utils.BITCOIN_ONLY:
from apps.stellar.helpers import address_from_public_key, public_key_from_address, validate_full_path
from apps.stellar.helpers import address_from_public_key, public_key_from_address
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -37,32 +36,6 @@ class TestStellarAddress(unittest.TestCase):
with self.assertRaises(ProcessError):
public_key_from_address('GCN2K2HG53AWX2SP5UHRPMJUUHLJF2XBTGSXROTPWRGAYJCDDP63J2AA') # invalid checksum
def test_paths(self):
# 44'/148'/a' is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 148 | HARDENED],
[44 | HARDENED, 148 | HARDENED, 0],
[44 | HARDENED, 148 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 148 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 148 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 148 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 148 | HARDENED, 9999000 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 148 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 148 | HARDENED, 3 | HARDENED],
[44 | HARDENED, 148 | HARDENED, 9 | HARDENED],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == '__main__':
unittest.main()

31
core/tests/test_apps.tezos.address.py
Unescape View File

@ -4,7 +4,6 @@ from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY:
from apps.tezos.sign_tx import _get_address_from_contract
from apps.tezos.helpers import validate_full_path
from trezor.messages import TezosContractType
from trezor.messages.TezosContractID import TezosContractID
@ -41,36 +40,6 @@ class TestTezosAddress(unittest.TestCase):
for i, contract in enumerate(contracts):
self.assertEqual(_get_address_from_contract(contract), outputs[i])
def test_paths(self):
# 44'/1729'/a' is correct
incorrect_paths = [
[44 | HARDENED],
[44 | HARDENED, 1729 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 0],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 0],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 1, 0],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 0, 0],
[44 | HARDENED, 1729 | HARDENED, 1 | HARDENED, 1 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 9999000 | HARDENED],
[44 | HARDENED, 60 | HARDENED, 0 | HARDENED, 0, 0],
[1 | HARDENED, 1 | HARDENED, 1 | HARDENED],
]
correct_paths = [
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 3 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 9 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 3 | HARDENED],
[44 | HARDENED, 1729 | HARDENED, 0 | HARDENED, 9 | HARDENED],
]
for path in incorrect_paths:
self.assertFalse(validate_full_path(path))
for path in correct_paths:
self.assertTrue(validate_full_path(path))
if __name__ == "__main__":
unittest.main()

Write Preview
Loading…
Cancel
Save