arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-11-22 15:38:11 +00:00
Code Issues Releases Wiki Activity

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

Browse Source
This commit is contained in:
matejcik 2020-09-23 12:31:07 +02:00 committed by matejcik
parent 5a97a5111b
commit eadf8ab25f
24 changed files with 241 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
core/tests/test_apps.binance.address.py
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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()

60
core/tests/test_apps.nem.address.py
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
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
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
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()