arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2024-11-22 23:48:12 +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 from trezor.crypto.curve import secp256k1
if not utils.BITCOIN_ONLY: 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -20,33 +20,5 @@ class TestBinanceAddress(unittest.TestCase):
self.assertEqual(address, expected_address) 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__': if __name__ == '__main__':
unittest.main() unittest.main()

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

@ -1,12 +1,12 @@
from common import * from common import *
from trezor.crypto import bip32, bip39 from trezor.crypto import bip32, bip39
from trezor.messages.GetAddress import GetAddress
from trezor.utils import HashWriter 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.common import coins
from apps.bitcoin import scripts from apps.bitcoin import scripts
from apps.bitcoin.addresses import * from apps.bitcoin.addresses import *
from apps.bitcoin.keychain import validate_path_against_script_type
from apps.bitcoin.writers import * from apps.bitcoin.writers import *
@ -32,17 +32,17 @@ class TestAddress(unittest.TestCase):
seed = bip39.seed(' '.join(['all'] * 12), '') seed = bip39.seed(' '.join(['all'] * 12), '')
root = bip32.from_seed(seed, 'secp256k1') 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) address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2N1LGaGg836mqSQqiuUBLfcyGBhyZbremDX') 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) address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2NFWLCJQBSpz1oUJwwLpX8ECifFWGznBVqs') 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) address = address_p2wpkh_in_p2sh(node.public_key(), coin)
self.assertEqual(address, '2N4Q5FhU2497BryFfUgbqkAJE87aKHUhXMp') self.assertEqual(address, '2N4Q5FhU2497BryFfUgbqkAJE87aKHUhXMp')
@ -129,96 +129,102 @@ class TestAddress(unittest.TestCase):
# def test_multisig_address_p2wsh(self): # def test_multisig_address_p2wsh(self):
# todo couldn't find test data # 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): def test_paths_btc(self):
incorrect_derivation_paths = [ incorrect_derivation_paths = [
([49 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # invalid length ([H_(49)], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # too many HARDENED ([H_(49), H_(0), H_(0), H_(0), H_(0)], InputScriptType.SPENDP2SHWITNESS), # too many HARDENED
([49 | HARDENED, 0 | HARDENED], InputScriptType.SPENDP2SHWITNESS), # invalid length ([H_(49), H_(0)], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid length ([H_(49), H_(0), H_(0), 0, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid length
([49 | HARDENED, 123 | HARDENED, 0 | HARDENED, 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid slip44 ([H_(49), H_(123), H_(0), 0, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid slip44
([49 | HARDENED, 0 | HARDENED, 1000 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), # account too high ([H_(49), H_(0), H_(1000), 0, 0], InputScriptType.SPENDP2SHWITNESS), # account too high
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 2, 0], InputScriptType.SPENDP2SHWITNESS), # invalid y ([H_(49), H_(0), H_(1), 2, 0], InputScriptType.SPENDP2SHWITNESS), # invalid y
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDP2SHWITNESS), # address index too high ([H_(49), H_(0), H_(1), 0, 10000000], InputScriptType.SPENDP2SHWITNESS), # address index too high
([84 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high ([H_(84), H_(0), H_(1), 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([49 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), # invalid input type ([H_(49), H_(0), H_(1), 0, 0], InputScriptType.SPENDWITNESS), # invalid input type
([84 | HARDENED, 0 | HARDENED, 1 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid input type ([H_(84), H_(0), H_(1), 0, 0], InputScriptType.SPENDP2SHWITNESS), # invalid input type
([49 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG), # invalid input type ([H_(49), H_(0), H_(5), 0, 10], InputScriptType.SPENDMULTISIG), # invalid input type
] ]
correct_derivation_paths = [ 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 ([H_(44), H_(0), H_(0), 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), ([H_(44), H_(0), H_(0), 0, 1], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(0), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), ([H_(49), H_(0), H_(0), 0, 0], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDP2SHWITNESS), ([H_(49), H_(0), H_(0), 1, 0], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDP2SHWITNESS), ([H_(49), H_(0), H_(0), 0, 1123], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDP2SHWITNESS), ([H_(49), H_(0), H_(0), 1, 44444], InputScriptType.SPENDP2SHWITNESS),
([49 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDP2SHWITNESS), ([H_(49), H_(0), H_(5), 0, 0], InputScriptType.SPENDP2SHWITNESS),
([84 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), ([H_(84), H_(0), H_(0), 0, 0], InputScriptType.SPENDWITNESS),
([84 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), ([H_(84), H_(0), H_(5), 0, 0], InputScriptType.SPENDWITNESS),
([84 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDWITNESS), ([H_(84), H_(0), H_(5), 0, 10], InputScriptType.SPENDWITNESS),
([48 | HARDENED, 0 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG), ([H_(48), H_(0), H_(5), H_(0), 0, 10], InputScriptType.SPENDMULTISIG),
] ]
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
for path, input_type in incorrect_derivation_paths: 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: 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.assertTrue(self.validate([H_(44), H_(0), H_(0), 0, 0], coin, InputScriptType.SPENDADDRESS))
self.assertFalse(validate_full_path([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0, 0], coin, InputScriptType.SPENDWITNESS)) self.assertFalse(self.validate([H_(44), H_(0), H_(0), 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))
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
def test_paths_bch(self): def test_paths_bch(self):
incorrect_derivation_paths = [ incorrect_derivation_paths = [
([44 | HARDENED], InputScriptType.SPENDADDRESS), # invalid length ([H_(44)], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], InputScriptType.SPENDADDRESS), # too many HARDENED ([H_(44), H_(145), H_(0), H_(0), H_(0)], 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 ([H_(49), H_(145), H_(0), 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' ([H_(84), H_(145), H_(1), 0, 1], InputScriptType.SPENDWITNESS), # and neither is 84'
([44 | HARDENED, 145 | HARDENED], InputScriptType.SPENDADDRESS), # invalid length ([H_(44), H_(145)], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid length ([H_(44), H_(145), H_(0), 0, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid length
([44 | HARDENED, 123 | HARDENED, 0 | HARDENED, 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid slip44 ([H_(44), H_(123), H_(0), 0, 0, 0], InputScriptType.SPENDADDRESS), # invalid slip44
([44 | HARDENED, 145 | HARDENED, 1000 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), # account too high ([H_(44), H_(145), H_(1000), 0, 0], InputScriptType.SPENDADDRESS), # account too high
([44 | HARDENED, 145 | HARDENED, 1 | HARDENED, 2, 0], InputScriptType.SPENDADDRESS), # invalid y ([H_(44), H_(145), H_(1), 2, 0], InputScriptType.SPENDADDRESS), # invalid y
([44 | HARDENED, 145 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDADDRESS), # address index too high ([H_(44), H_(145), H_(1), 0, 10000000], InputScriptType.SPENDADDRESS), # address index too high
([84 | HARDENED, 145 | HARDENED, 1 | HARDENED, 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high ([H_(84), H_(145), H_(1), 0, 10000000], InputScriptType.SPENDWITNESS), # address index too high
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDWITNESS), # input type mismatch ([H_(44), H_(145), H_(0), 0, 0], InputScriptType.SPENDWITNESS), # input type mismatch
] ]
correct_derivation_paths = [ correct_derivation_paths = [
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(145), H_(0), 0, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(145), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDADDRESS), ([H_(44), H_(145), H_(0), 0, 1123], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDADDRESS), ([H_(44), H_(145), H_(0), 1, 44444], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(145), H_(5), 0, 0], InputScriptType.SPENDADDRESS),
([48 | HARDENED, 145 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDMULTISIG), ([H_(48), H_(145), H_(0), H_(0), 0, 0], InputScriptType.SPENDMULTISIG),
([48 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 0], InputScriptType.SPENDMULTISIG), ([H_(48), H_(145), H_(5), H_(0), 0, 0], InputScriptType.SPENDMULTISIG),
([48 | HARDENED, 145 | HARDENED, 5 | HARDENED, 0, 10], InputScriptType.SPENDMULTISIG), ([H_(48), H_(145), H_(5), H_(0), 0, 10], InputScriptType.SPENDMULTISIG),
] ]
coin = coins.by_name('Bcash') # segwit is disabled coin = coins.by_name('Bcash') # segwit is disabled
for path, input_type in incorrect_derivation_paths: 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: 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
def test_paths_other(self): def test_paths_other(self):
incorrect_derivation_paths = [ 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 = [ correct_derivation_paths = [
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(3), H_(0), 0, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 1, 0], InputScriptType.SPENDADDRESS), ([H_(44), H_(3), H_(0), 1, 0], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0, 1123], InputScriptType.SPENDADDRESS), ([H_(44), H_(3), H_(0), 0, 1123], InputScriptType.SPENDADDRESS),
([44 | HARDENED, 3 | HARDENED, 0 | HARDENED, 1, 44444], InputScriptType.SPENDADDRESS), ([H_(44), H_(3), H_(0), 1, 44444], InputScriptType.SPENDADDRESS),
] ]
coin = coins.by_name('Dogecoin') # segwit is disabled coin = coins.by_name('Dogecoin') # segwit is disabled
for path, input_type in correct_derivation_paths: 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: 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__': 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") self.assertEqual(coin.coin_name, "Bitcoin")
valid_addresses = ( valid_addresses = (
[44 | HARDENED, 0 | HARDENED], [H_(44), H_(0), H_(0), 0, 0],
[45 | HARDENED, 123456], [H_(45), 99, 1, 1000],
[48 | HARDENED, 0 | HARDENED], [H_(48), H_(0), H_(0), H_(2), 1, 1000],
[49 | HARDENED, 0 | HARDENED], [H_(49), H_(0), H_(0), 0, 10],
[84 | HARDENED, 0 | HARDENED], [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 = ( invalid_addresses = (
[43 | HARDENED, 0 | HARDENED], [H_(43), H_(0), H_(0), 0, 0],
[44 | HARDENED, 1 | HARDENED], [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: for addr in valid_addresses:
@ -44,15 +52,23 @@ class TestBitcoinKeychain(unittest.TestCase):
self.assertEqual(coin.coin_name, "Testnet") self.assertEqual(coin.coin_name, "Testnet")
valid_addresses = ( valid_addresses = (
[44 | HARDENED, 1 | HARDENED], [H_(44), H_(1), H_(0), 0, 0],
[45 | HARDENED, 123456], [H_(45), 99, 1, 1000],
[48 | HARDENED, 1 | HARDENED], [H_(48), H_(1), H_(0), H_(2), 1, 1000],
[49 | HARDENED, 1 | HARDENED], [H_(49), H_(1), H_(0), 0, 10],
[84 | HARDENED, 1 | HARDENED], [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 = ( invalid_addresses = (
[43 | HARDENED, 1 | HARDENED], [H_(43), H_(1), H_(0), 0, 0],
[44 | HARDENED, 0 | HARDENED], [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: for addr in valid_addresses:
@ -64,7 +80,7 @@ class TestBitcoinKeychain(unittest.TestCase):
def test_unspecified(self): def test_unspecified(self):
keychain, coin = await_result(get_keychain_for_coin(wire.DUMMY_CONTEXT, None)) keychain, coin = await_result(get_keychain_for_coin(wire.DUMMY_CONTEXT, None))
self.assertEqual(coin.coin_name, "Bitcoin") 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): def test_unknown(self):
with self.assertRaises(wire.DataError): with self.assertRaises(wire.DataError):
@ -85,20 +101,29 @@ class TestAltcoinKeychains(unittest.TestCase):
self.assertEqual(coin.coin_name, "Bcash") self.assertEqual(coin.coin_name, "Bcash")
self.assertFalse(coin.segwit) self.assertFalse(coin.segwit)
self.assertIsNotNone(coin.fork_id)
valid_addresses = ( valid_addresses = (
[44 | HARDENED, 145 | HARDENED], [H_(44), H_(145), H_(0), 0, 0],
[44 | HARDENED, 0 | HARDENED], # Bitcoin paths should be allowed, as Bcash has strong replay protection
[45 | HARDENED, 123456], [H_(44), H_(0), H_(0), 0, 0],
[48 | HARDENED, 145 | HARDENED], [H_(45), 99, 1, 1000],
[48 | HARDENED, 0 | HARDENED], [H_(48), H_(145), H_(0), H_(0), 1, 1000],
[H_(48), H_(0), H_(0), H_(0), 1, 1000],
) )
invalid_addresses = ( invalid_addresses = (
[43 | HARDENED, 145 | HARDENED], [H_(43), H_(145), H_(0), 0, 0],
[43 | HARDENED, 0 | HARDENED], [44, 145, 0, 0, 0],
[49 | HARDENED, 145 | HARDENED], [H_(44), H_(145), H_(0)],
[49 | HARDENED, 0 | HARDENED], [H_(44), H_(145), H_(0), 0, 0, 0],
[84 | HARDENED, 145 | HARDENED], # segwit:
[84 | HARDENED, 0 | HARDENED], [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: for addr in valid_addresses:
@ -115,18 +140,27 @@ class TestAltcoinKeychains(unittest.TestCase):
self.assertTrue(coin.segwit) self.assertTrue(coin.segwit)
valid_addresses = ( valid_addresses = (
[44 | HARDENED, 2 | HARDENED], [H_(44), H_(2), H_(0), 0, 0],
[45 | HARDENED, 123456], [H_(45), 99, 1, 1000],
[48 | HARDENED, 2 | HARDENED], [H_(48), H_(2), H_(0), H_(2), 1, 1000],
[49 | HARDENED, 2 | HARDENED], [H_(49), H_(2), H_(0), 0, 10],
[84 | HARDENED, 2 | HARDENED], [H_(84), H_(2), H_(0), 0, 10],
) )
invalid_addresses = ( invalid_addresses = (
[43 | HARDENED, 2 | HARDENED], [H_(43), H_(2), H_(0), 0, 0],
[44 | HARDENED, 0 | HARDENED], # Bitcoin paths:
[48 | HARDENED, 0 | HARDENED], [H_(44), H_(0), H_(0), 0, 0],
[49 | HARDENED, 0 | HARDENED], [H_(49), H_(0), H_(0), 0, 0],
[84 | HARDENED, 0 | HARDENED], [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: 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 import coins
from apps.common.keychain import Keychain 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 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.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 from apps.bitcoin.multisig import multisig_get_pubkeys
@ -17,7 +17,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wpkh_gen_proof(self): def test_p2wpkh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '') 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"" commitment_data = b""
node = keychain.derive([84 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0]) 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): def test_p2wpkh_in_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '') 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"" commitment_data = b""
node = keychain.derive([49 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0]) 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): def test_p2pkh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), 'TREZOR') 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"" commitment_data = b""
node = keychain.derive([44 | HARDENED, 0 | HARDENED, 0 | HARDENED, 1, 0]) 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): def test_p2wpkh_verify_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), 'TREZOR') 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"" commitment_data = b""
# Proof for "all all ... all" seed without passphrase. # Proof for "all all ... all" seed without passphrase.
@ -107,7 +107,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wsh_gen_proof(self): def test_p2wsh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '') 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" commitment_data = b"TREZOR"
nodes = [] nodes = []
@ -167,7 +167,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2wsh_in_p2sh_gen_proof(self): def test_p2wsh_in_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '') 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"" commitment_data = b""
nodes = [] nodes = []
@ -241,7 +241,7 @@ class TestOwnershipProof(unittest.TestCase):
def test_p2sh_gen_proof(self): def test_p2sh_gen_proof(self):
coin = coins.by_name('Bitcoin') coin = coins.by_name('Bitcoin')
seed = bip39.seed(' '.join(['all'] * 12), '') 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" commitment_data = b"TREZOR"
nodes = [] 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.bitcoin.writers import get_tx_hash
from apps.common import coins from apps.common import coins
from apps.common.keychain import Keychain from apps.common.keychain import Keychain
from apps.common.paths import AlwaysMatchingSchema
from trezor.messages.SignTx import SignTx from trezor.messages.SignTx import SignTx
from trezor.messages.TxInput import TxInput from trezor.messages.TxInput import TxInput
from trezor.messages.TxOutput import TxOutput from trezor.messages.TxOutput import TxOutput
@ -89,7 +90,7 @@ class TestSegwitBip143NativeP2WPKH(unittest.TestCase):
txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey) txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey)
bip143.add_output(txo_bin, 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) node = keychain.derive(self.inp2.address_n)
# test data public key hash # 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.bitcoin.writers import get_tx_hash
from apps.common import coins from apps.common import coins
from apps.common.keychain import Keychain from apps.common.keychain import Keychain
from apps.common.paths import AlwaysMatchingSchema
from trezor.messages.SignTx import SignTx from trezor.messages.SignTx import SignTx
from trezor.messages.TxInput import TxInput from trezor.messages.TxInput import TxInput
from trezor.messages.TxOutput import TxOutput from trezor.messages.TxOutput import TxOutput
@ -75,7 +76,7 @@ class TestSegwitBip143(unittest.TestCase):
txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey) txo_bin = PrevOutput(amount=txo.amount, script_pubkey=script_pubkey)
bip143.add_output(txo_bin, 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) node = keychain.derive(self.inp1.address_n)
# test data public key hash # 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 import coins
from apps.common.keychain import Keychain 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 import helpers, bitcoin
from apps.bitcoin.sign_tx.approvers import BasicApprover 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer()
@ -347,7 +347,7 @@ class TestSignSegwitTxNativeP2WPKH(unittest.TestCase):
None None
] ]
ns = get_namespaces_for_coin(coin) ns = get_schemas_for_coin(coin)
keychain = Keychain(seed, coin.curve_name, ns) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() 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 import coins
from apps.common.keychain import Keychain 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 import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer() 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer() 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 import coins
from apps.common.keychain import Keychain 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 import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoin.Bitcoin(tx, keychain, coin, approver).signer() 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 import coins
from apps.common.keychain import Keychain 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 import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer() 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer() 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 import coins
from apps.common.keychain import Keychain 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 import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover 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', '') 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) approver = BasicApprover(tx, coin_bitcoin)
signer = bitcoin.Bitcoin(tx, keychain, coin_bitcoin, approver).signer() signer = bitcoin.Bitcoin(tx, keychain, coin_bitcoin, approver).signer()
for request, response in chunks(messages, 2): 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 import coins
from apps.common.keychain import Keychain 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 import bitcoin, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover 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', '') 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) keychain = Keychain(seed, coin_bitcoin.curve_name, ns)
approver = BasicApprover(tx, coin_bitcoin) approver = BasicApprover(tx, coin_bitcoin)
signer = bitcoin.Bitcoin(tx, keychain, coin_bitcoin, approver).signer() 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 import coins
from apps.common.keychain import Keychain 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 import bitcoinlike, helpers
from apps.bitcoin.sign_tx.approvers import BasicApprover from apps.bitcoin.sign_tx.approvers import BasicApprover
@ -101,7 +101,7 @@ class TestSignTx_GRS(unittest.TestCase):
] ]
seed = bip39.seed(' '.join(['all'] * 12), '') 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) keychain = Keychain(seed, coin.curve_name, ns)
approver = BasicApprover(tx, coin) approver = BasicApprover(tx, coin)
signer = bitcoinlike.Bitcoinlike(tx, keychain, coin, approver).signer() 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 from apps.common import HARDENED, seed
if not utils.BITCOIN_ONLY: if not utils.BITCOIN_ONLY:
from apps.cardano.address import ( from apps.cardano.address import derive_human_readable_address
derive_human_readable_address, from apps.cardano.byron_address import _address_hash
validate_full_path,
)
from apps.cardano.byron_address import (
_get_address_root,
_address_hash,
)
from apps.cardano.helpers import network_ids, protocol_magics from apps.cardano.helpers import network_ids, protocol_magics
from apps.cardano.seed import Keychain 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') 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): def test_slip39_128(self):
mnemonics = [ mnemonics = [
"extra extend academic bishop cricket bundle tofu goat apart victim " "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): def is_equal(a, b):
if isinstance(a, range) and isinstance(b, range): 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.start == b.start and a.step == b.step and a.stop == b.stop
return a == b return set(a) == set(b)
ensure( ensure(
all(is_equal(a, b) for a, b in zip(schema_a.schema, schema_b.schema)) 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, [H_(44), H_(0), H_(0), H_(0), H_(0)] * 10,
] ]
for path in paths: for path in paths:
self.assertMatch(SCHEMA_ANY_PATH, path) self.assertMatch(AlwaysMatchingSchema, path)
self.assertMismatch(SCHEMA_NO_MATCH, path) self.assertMismatch(NeverMatchingSchema, path)
def test_pattern_fixed(self): def test_pattern_fixed(self):
pattern = "m/44'/0'/0'/0/0" 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: if not utils.BITCOIN_ONLY:
from apps.eos.get_public_key import _get_public_key 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -44,31 +44,6 @@ class TestEosGetPublicKey(unittest.TestCase):
self.assertEqual(wif, wif_keys[index]) self.assertEqual(wif, wif_keys[index])
self.assertEqual(public_key_to_wif(public_key), 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__': if __name__ == '__main__':
unittest.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 from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY: if not utils.BITCOIN_ONLY:
from apps.ethereum.address import address_from_bytes, bytes_from_address, validate_full_path from apps.ethereum.address import address_from_bytes
from apps.ethereum.networks import NetworkInfo, by_chain_id from apps.ethereum.networks import NetworkInfo
@unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -54,34 +54,6 @@ class TestEthereumGetAddress(unittest.TestCase):
h = address_from_bytes(b, n) h = address_from_bytes(b, n)
self.assertEqual(h, '0x' + s) 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__': if __name__ == '__main__':
unittest.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 storage import cache
from trezor import wire from trezor import wire
from trezor.crypto import bip39 from trezor.crypto import bip39
from apps.common.keychain import get_keychain
from apps.common.paths import HARDENED from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY: if not utils.BITCOIN_ONLY:
from apps.ethereum import CURVE
from apps.ethereum.keychain import ( from apps.ethereum.keychain import (
from_address_n, PATTERNS_ADDRESS,
_schemas_from_address_n,
with_keychain_from_path, with_keychain_from_path,
with_keychain_from_chain_id, with_keychain_from_chain_id,
) )
@ -21,19 +24,23 @@ class TestEthereumKeychain(unittest.TestCase):
def _check_keychain(self, keychain, slip44_id): def _check_keychain(self, keychain, slip44_id):
# valid address should succeed # valid address should succeed
valid_addresses = ( valid_addresses = (
[44 | HARDENED, slip44_id | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED], [44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED],
[44 | HARDENED, slip44_id | HARDENED, 19 | 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, 0],
[44 | HARDENED, slip44_id | HARDENED, 0 | HARDENED, 0, 999],
) )
for addr in valid_addresses: for addr in valid_addresses:
keychain.derive(addr) keychain.derive(addr)
# invalid address should fail # invalid address should fail
invalid_addresses = ( invalid_addresses = (
[44 | HARDENED], [44 | HARDENED],
[44 | HARDENED, 0 | HARDENED], [44 | HARDENED, slip44_id | HARDENED],
[42 | HARDENED, slip44_id | HARDENED], [44 | HARDENED, 0 | HARDENED, 0 | HARDENED],
[42 | HARDENED, slip44_id | HARDENED, 0 | HARDENED],
[0 | 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: for addr in invalid_addresses:
self.assertRaises( self.assertRaises(
@ -45,35 +52,27 @@ class TestEthereumKeychain(unittest.TestCase):
seed = bip39.seed(" ".join(["all"] * 12), "") seed = bip39.seed(" ".join(["all"] * 12), "")
cache.set(cache.APP_COMMON_SEED, seed) 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): def test_from_address_n(self):
# valid keychain m/44'/60'/0' # valid keychain m/44'/60'/0'
keychain = await_result( keychain = self.from_address_n([44 | HARDENED, 60 | HARDENED, 0 | HARDENED])
from_address_n(
wire.DUMMY_CONTEXT, [44 | HARDENED, 60 | HARDENED, 0 | HARDENED]
)
)
self._check_keychain(keychain, 60) self._check_keychain(keychain, 60)
def test_from_address_n_unknown(self): def test_from_address_n_unknown(self):
# try Bitcoin slip44 id m/44'/0'/0' # try Bitcoin slip44 id m/44'/0'/0'
with self.assertRaises(wire.DataError): schemas = tuple(_schemas_from_address_n(PATTERNS_ADDRESS, [44 | HARDENED, 0 | HARDENED, 0 | HARDENED]))
await_result( self.assertEqual(schemas, ())
from_address_n(
wire.DUMMY_CONTEXT, [44 | HARDENED, 0 | HARDENED, 0 | HARDENED]
)
)
def test_bad_address_n(self): def test_bad_address_n(self):
# keychain generated from valid slip44 id but invalid address m/0'/60'/0' # keychain generated from valid slip44 id but invalid address m/0'/60'/0'
keychain = await_result( keychain = self.from_address_n([0 | HARDENED, 60 | HARDENED, 0 | HARDENED])
from_address_n(
wire.DUMMY_CONTEXT, [0 | HARDENED, 60 | HARDENED, 0 | HARDENED]
)
)
self._check_keychain(keychain, 60) self._check_keychain(keychain, 60)
def test_with_keychain_from_path(self): def test_with_keychain_from_path(self):
@with_keychain_from_path @with_keychain_from_path(*PATTERNS_ADDRESS)
async def handler(ctx, msg, keychain): async def handler(ctx, msg, keychain):
self._check_keychain(keychain, msg.address_n[1] & ~HARDENED) 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): def test_with_keychain_from_chain_id(self):
@with_keychain_from_chain_id @with_keychain_from_chain_id
async def handler_chain_id(ctx, msg, keychain): async def handler_chain_id(ctx, msg, keychain):
network = by_chain_id(msg.chain_id) slip44_id = msg.address_n[1] & ~HARDENED
# standard tests # standard tests
self._check_keychain(keychain, network.slip44) self._check_keychain(keychain, slip44_id)
# provided address should succeed too # provided address should succeed too
keychain.derive(msg.address_n) 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): with self.assertRaises(wire.DataError):
await_result( # unknown chain_id await_result( # unknown chain_id
handler_chain_id( handler_chain_id(
@ -149,7 +161,7 @@ class TestEthereumKeychain(unittest.TestCase):
handler_chain_id( handler_chain_id(
wire.DUMMY_CONTEXT, wire.DUMMY_CONTEXT,
EthereumSignTx( EthereumSignTx(
address_n=[44 | HARDENED, 60 | HARDENED, 0 | HARDENED], address_n=[44 | HARDENED, 61 | HARDENED, 0 | HARDENED],
chain_id=2, chain_id=2,
), ),
) )
@ -158,9 +170,9 @@ class TestEthereumKeychain(unittest.TestCase):
def test_missing_chain_id(self): def test_missing_chain_id(self):
@with_keychain_from_chain_id @with_keychain_from_chain_id
async def handler_chain_id(ctx, msg, keychain): 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 # standard tests
self._check_keychain(keychain, network.slip44) self._check_keychain(keychain, slip44_id)
# provided address should succeed too # provided address should succeed too
keychain.derive(msg.address_n) 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: if not utils.BITCOIN_ONLY:
from trezor.crypto import nem 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -35,46 +35,26 @@ class TestNemAddress(unittest.TestCase):
validity = nem.validate_address('NCUKWDY3J3THKQHAKOK5ALF6ANJQABZHCH7VN6DP', NEM_NETWORK_TESTNET) validity = nem.validate_address('NCUKWDY3J3THKQHAKOK5ALF6ANJQABZHCH7VN6DP', NEM_NETWORK_TESTNET)
self.assertFalse(validity) self.assertFalse(validity)
def test_paths(self): def test_check_path(self):
# 44'/43'/0'/0'/0' # mainnet path:
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED])) self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_MAINNET))
# 44'/43'/0'/0'/0' # should be valid on mijin as well:
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0 | HARDENED])) self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_MIJIN))
# 44'/1'/0'/0'/0' testnet # testnet path:
self.assertTrue(check_path([44 | HARDENED, 1 | HARDENED, 3 | HARDENED, 0 | HARDENED, 0 | HARDENED], network=0x98)) self.assertTrue(check_path([44 | HARDENED, 1 | HARDENED, 0 | HARDENED, 0 | HARDENED, 0 | HARDENED], NEM_NETWORK_TESTNET))
# 44'/43'/0' # short path (check_path does not validate pattern match):
self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED, 0 | HARDENED])) self.assertTrue(check_path([44 | HARDENED, 43 | HARDENED], NEM_NETWORK_MAINNET))
# 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]))
# 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__': if __name__ == '__main__':

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

@ -1,8 +1,7 @@
from common import * from common import *
from apps.common.paths import HARDENED
if not utils.BITCOIN_ONLY: 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -18,33 +17,6 @@ class TestRippleAddress(unittest.TestCase):
addr = address_from_public_key(unhexlify('0282ee731039929e97db6aec242002e9aa62cd62b989136df231f4bb9b8b7c7eb2')) addr = address_from_public_key(unhexlify('0282ee731039929e97db6aec242002e9aa62cd62b989136df231f4bb9b8b7c7eb2'))
self.assertEqual(addr, 'rKzE5DTyF9G6z7k7j27T2xEas2eMo85kmw') 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__': if __name__ == '__main__':
unittest.main() unittest.main()

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

@ -1,9 +1,8 @@
from common import * from common import *
from apps.common.paths import HARDENED
from trezor.wire import ProcessError from trezor.wire import ProcessError
if not utils.BITCOIN_ONLY: 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") @unittest.skipUnless(not utils.BITCOIN_ONLY, "altcoin")
@ -37,32 +36,6 @@ class TestStellarAddress(unittest.TestCase):
with self.assertRaises(ProcessError): with self.assertRaises(ProcessError):
public_key_from_address('GCN2K2HG53AWX2SP5UHRPMJUUHLJF2XBTGSXROTPWRGAYJCDDP63J2AA') # invalid checksum 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__': if __name__ == '__main__':
unittest.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: if not utils.BITCOIN_ONLY:
from apps.tezos.sign_tx import _get_address_from_contract 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 import TezosContractType
from trezor.messages.TezosContractID import TezosContractID from trezor.messages.TezosContractID import TezosContractID
@ -41,36 +40,6 @@ class TestTezosAddress(unittest.TestCase):
for i, contract in enumerate(contracts): for i, contract in enumerate(contracts):
self.assertEqual(_get_address_from_contract(contract), outputs[i]) 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__": if __name__ == "__main__":
unittest.main() unittest.main()