arno/trezor-firmware
1
0
Fork 0
mirror of https://github.com/trezor/trezor-firmware.git synced 2025-04-26 03:59:08 +00:00
Code Issues Releases Wiki Activity

tests: refactor T1 changepin test

Browse Source
This commit is contained in:
matejcik 2020-04-27 16:37:16 +02:00 committed by matejcik
parent fc6c99c6f9
commit 2499a6d6da
1 changed files with 148 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

328
tests/device_tests/test_msg_changepin.py
View File

@ -16,255 +16,193 @@
import pytest import pytest
from trezorlib import messages as proto from trezorlib import device, messages
from trezorlib.exceptions import TrezorFailure
PIN4 = "1234" PIN4 = "1234"
PIN6 = "789456" PIN6 = "789456"
@pytest.mark.skip_t2 pytestmark = pytest.mark.skip_t2
class TestMsgChangepin:
def test_set_pin(self, client):
features = client.call_raw(proto.Initialize()) def _check_pin(client, pin):
assert features.pin_protection is False client.clear_session()
with client:
client.use_pin_sequence([pin])
client.set_expected_responses([messages.PinMatrixRequest(), messages.Address()])
client.call(messages.GetAddress())
def _check_no_pin(client):
client.clear_session()
with client:
client.set_expected_responses([messages.Address()])
client.call(messages.GetAddress())
def test_set_pin(client):
assert client.features.pin_protection is False
# Check that there's no PIN protection # Check that there's no PIN protection
ret = client.call_raw(proto.GetAddress()) _check_no_pin(client)
assert isinstance(ret, proto.Address)
# Let's set new PIN # Let's set new PIN
ret = client.call_raw(proto.ChangePin()) with client:
assert isinstance(ret, proto.ButtonRequest) client.use_pin_sequence([PIN6, PIN6])
client.set_expected_responses(
# Press button [
client.debug.press_yes() messages.ButtonRequest(code=messages.ButtonRequestType.ProtectCall),
ret = client.call_raw(proto.ButtonAck()) messages.PinMatrixRequest(),
messages.PinMatrixRequest(),
# Send the PIN for first time messages.Success(),
assert isinstance(ret, proto.PinMatrixRequest) messages.Features(),
pin_encoded = client.debug.encode_pin(PIN6) ]
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) )
device.change_pin(client)
# Send the PIN for second time
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN6)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Now we're done
assert isinstance(ret, proto.Success)
# Check that there's PIN protection now # Check that there's PIN protection now
features = client.call_raw(proto.Initialize()) assert client.features.pin_protection is True
assert features.pin_protection is True
# Check that the PIN is correct # Check that the PIN is correct
self.check_pin(client, PIN6) _check_pin(client, PIN6)
@pytest.mark.setup_client(pin=True)
def test_change_pin(self, client):
features = client.call_raw(proto.Initialize())
assert features.pin_protection is True
@pytest.mark.setup_client(pin=PIN4)
def test_change_pin(client):
assert client.features.pin_protection is True
# Check that there's PIN protection # Check that there's PIN protection
ret = client.call_raw(proto.GetAddress()) _check_pin(client, PIN4)
assert isinstance(ret, proto.PinMatrixRequest)
client.call_raw(proto.Cancel())
# Check current PIN value
self.check_pin(client, PIN4)
# Let's change PIN # Let's change PIN
ret = client.call_raw(proto.ChangePin()) with client:
assert isinstance(ret, proto.ButtonRequest) client.use_pin_sequence([PIN4, PIN6, PIN6])
client.set_expected_responses(
# Press button [
client.debug.press_yes() messages.ButtonRequest(code=messages.ButtonRequestType.ProtectCall),
ret = client.call_raw(proto.ButtonAck()) messages.PinMatrixRequest(),
messages.PinMatrixRequest(),
# Send current PIN messages.PinMatrixRequest(),
assert isinstance(ret, proto.PinMatrixRequest) messages.Success(),
pin_encoded = client.debug.read_pin_encoded() messages.Features(),
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) ]
)
# Send new PIN for first time device.change_pin(client)
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN6)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Send the PIN for second time
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN6)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Now we're done
assert isinstance(ret, proto.Success)
# Check that there's still PIN protection now # Check that there's still PIN protection now
features = client.call_raw(proto.Initialize()) assert client.features.pin_protection is True
assert features.pin_protection is True
# Check that the PIN is correct # Check that the PIN is correct
self.check_pin(client, PIN6) _check_pin(client, PIN6)
@pytest.mark.setup_client(pin=True)
def test_remove_pin(self, client):
features = client.call_raw(proto.Initialize())
assert features.pin_protection is True
@pytest.mark.setup_client(pin=PIN4)
def test_remove_pin(client):
assert client.features.pin_protection is True
# Check that there's PIN protection # Check that there's PIN protection
ret = client.call_raw(proto.GetAddress()) _check_pin(client, PIN4)
assert isinstance(ret, proto.PinMatrixRequest)
client.call_raw(proto.Cancel())
# Let's remove PIN # Let's remove PIN
ret = client.call_raw(proto.ChangePin(remove=True)) with client:
assert isinstance(ret, proto.ButtonRequest) client.use_pin_sequence([PIN4])
client.set_expected_responses(
# Press button [
client.debug.press_yes() messages.ButtonRequest(code=messages.ButtonRequestType.ProtectCall),
ret = client.call_raw(proto.ButtonAck()) messages.PinMatrixRequest(),
messages.Success(),
# Send current PIN messages.Features(),
assert isinstance(ret, proto.PinMatrixRequest) ]
pin_encoded = client.debug.read_pin_encoded() )
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) device.change_pin(client, remove=True)
# Now we're done
assert isinstance(ret, proto.Success)
# Check that there's no PIN protection now # Check that there's no PIN protection now
features = client.call_raw(proto.Initialize()) assert client.features.pin_protection is False
assert features.pin_protection is False _check_no_pin(client)
ret = client.call_raw(proto.GetAddress())
assert isinstance(ret, proto.Address)
def test_set_mismatch(self, client):
features = client.call_raw(proto.Initialize())
assert features.pin_protection is False
def test_set_mismatch(client):
assert client.features.pin_protection is False
# Check that there's no PIN protection # Check that there's no PIN protection
ret = client.call_raw(proto.GetAddress()) _check_no_pin(client)
assert isinstance(ret, proto.Address)
# Let's set new PIN # Let's set new PIN
ret = client.call_raw(proto.ChangePin()) with pytest.raises(TrezorFailure, match="PIN mismatch"), client:
assert isinstance(ret, proto.ButtonRequest) # use different PINs for first and second attempt. This will fail.
client.use_pin_sequence([PIN4, PIN6])
# Press button client.set_expected_responses(
client.debug.press_yes() [
ret = client.call_raw(proto.ButtonAck()) messages.ButtonRequest(code=messages.ButtonRequestType.ProtectCall),
messages.PinMatrixRequest(),
# Send the PIN for first time messages.PinMatrixRequest(),
assert isinstance(ret, proto.PinMatrixRequest) messages.Failure(),
pin_encoded = client.debug.encode_pin(PIN6) ]
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) )
device.change_pin(client)
# Send the PIN for second time, but with typo
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN4)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Now it should fail, because pins are different
assert isinstance(ret, proto.Failure)
# Check that there's still no PIN protection now # Check that there's still no PIN protection now
features = client.call_raw(proto.Initialize()) client.init_device()
assert features.pin_protection is False assert client.features.pin_protection is False
ret = client.call_raw(proto.GetAddress()) _check_no_pin(client)
assert isinstance(ret, proto.Address)
@pytest.mark.setup_client(pin=True)
def test_change_mismatch(self, client): @pytest.mark.setup_client(pin=PIN4)
features = client.call_raw(proto.Initialize()) def test_change_mismatch(client):
assert features.pin_protection is True assert client.features.pin_protection is True
# Let's set new PIN # Let's set new PIN
ret = client.call_raw(proto.ChangePin()) with pytest.raises(TrezorFailure, match="PIN mismatch"), client:
assert isinstance(ret, proto.ButtonRequest) client.use_pin_sequence([PIN4, PIN6, PIN6 + "3"])
client.set_expected_responses(
# Press button [
client.debug.press_yes() messages.ButtonRequest(code=messages.ButtonRequestType.ProtectCall),
ret = client.call_raw(proto.ButtonAck()) messages.PinMatrixRequest(),
messages.PinMatrixRequest(),
# Send current PIN messages.PinMatrixRequest(),
assert isinstance(ret, proto.PinMatrixRequest) messages.Failure(),
pin_encoded = client.debug.read_pin_encoded() ]
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded)) )
device.change_pin(client)
# Send the PIN for first time
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN6)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Send the PIN for second time, but with typo
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(PIN6 + "3")
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
# Now it should fail, because pins are different
assert isinstance(ret, proto.Failure)
# Check that there's still old PIN protection # Check that there's still old PIN protection
features = client.call_raw(proto.Initialize()) client.init_device()
assert features.pin_protection is True assert client.features.pin_protection is True
self.check_pin(client, PIN4) _check_pin(client, PIN4)
@pytest.mark.parametrize("invalid_pin", ("1204", "", "1234567891"))
def test_set_invalid(self, client, invalid_pin): @pytest.mark.parametrize("invalid_pin", ("1204", "", "1234567891"))
features = client.call_raw(proto.Initialize()) def test_set_invalid(client, invalid_pin):
assert features.pin_protection is False assert client.features.pin_protection is False
# Let's set an invalid PIN # Let's set an invalid PIN
ret = client.call_raw(proto.ChangePin()) ret = client.call_raw(messages.ChangePin())
assert isinstance(ret, proto.ButtonRequest) assert isinstance(ret, messages.ButtonRequest)
# Press button # Press button
client.debug.press_yes() client.debug.press_yes()
ret = client.call_raw(proto.ButtonAck()) ret = client.call_raw(messages.ButtonAck())
# Send a PIN containing an invalid digit # Send a PIN containing an invalid digit
assert isinstance(ret, proto.PinMatrixRequest) assert isinstance(ret, messages.PinMatrixRequest)
ret = client.call_raw(proto.PinMatrixAck(pin=invalid_pin)) ret = client.call_raw(messages.PinMatrixAck(pin=invalid_pin))
# Ensure the invalid PIN is detected # Ensure the invalid PIN is detected
assert isinstance(ret, proto.Failure) assert isinstance(ret, messages.Failure)
# Check that there's still no PIN protection now # Check that there's still no PIN protection now
features = client.call_raw(proto.Initialize()) client.init_device()
assert features.pin_protection is False assert client.features.pin_protection is False
ret = client.call_raw(proto.GetAddress()) _check_no_pin(client)
assert isinstance(ret, proto.Address)
@pytest.mark.parametrize("invalid_pin", ("1204", "", "1234567891"))
@pytest.mark.setup_client(pin=True)
def test_remove_invalid(self, client, invalid_pin):
features = client.call_raw(proto.Initialize())
assert features.pin_protection is True
# Let's change the PIN @pytest.mark.parametrize("invalid_pin", ("1204", "", "1234567891"))
ret = client.call_raw(proto.ChangePin(remove=True)) @pytest.mark.setup_client(pin=PIN4)
assert isinstance(ret, proto.ButtonRequest) def test_enter_invalid(client, invalid_pin):
assert client.features.pin_protection is True
# Press button # use an invalid PIN
client.debug.press_yes() ret = client.call_raw(messages.GetAddress())
ret = client.call_raw(proto.ButtonAck())
# Instead of the old PIN, send a PIN containing an invalid digit # Send a PIN containing an invalid digit
assert isinstance(ret, proto.PinMatrixRequest) assert isinstance(ret, messages.PinMatrixRequest)
ret = client.call_raw(proto.PinMatrixAck(pin=invalid_pin)) ret = client.call_raw(messages.PinMatrixAck(pin=invalid_pin))
# Ensure the invalid PIN is detected # Ensure the invalid PIN is detected
assert isinstance(ret, proto.Failure) assert isinstance(ret, messages.Failure)
# Check that there's still old PIN protection
features = client.call_raw(proto.Initialize())
assert features.pin_protection is True
self.check_pin(client, PIN4)
def check_pin(self, client, pin):
client.clear_session()
ret = client.call_raw(proto.GetAddress())
assert isinstance(ret, proto.PinMatrixRequest)
pin_encoded = client.debug.encode_pin(pin)
ret = client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
assert isinstance(ret, proto.Address)