test: make presign OLED evidence semantic

Author: BitHighlander

scripts/generate-test-report.py

@@ -35,6 +35,27 @@
 tx_api.configure_offline_fixtures(TX_FIXTURE_DIR)
 VERBOSE = False
 
+
+def reset_screenshot_capture(client):
+    """Start a fresh evidence sequence after fixture-only device setup.
+
+    KeepKeyTest.setUp() wipes the device and the setup_mnemonic_* helpers load
+    a public test seed. Those confirmations are prerequisites, not evidence
+    for the test that follows. Leaving them in the per-test directory allowed
+    a Wipe/import/lock frame to satisfy an unrelated OLED requirement.
+    """
+    if os.environ.get('KEEPKEY_SCREENSHOT') != '1':
+        return
+    screenshot_dir = getattr(client, 'screenshot_dir', None)
+    if not screenshot_dir:
+        raise RuntimeError('screenshot capture has no per-test directory')
+    os.makedirs(screenshot_dir, exist_ok=True)
+    for name in os.listdir(screenshot_dir):
+        if (name.startswith('btn') and name.endswith('.png') and
+                len(name) == len('btn00000.png')) or name == 'frames.json':
+            os.unlink(os.path.join(screenshot_dir, name))
+    client.screenshot_id = 0
+
 class KeepKeyTest(unittest.TestCase):
     def setUp(self):
         transport = config.TRANSPORT(*config.TRANSPORT_ARGS, **config.TRANSPORT_KWARGS)
@@ -77,28 +98,35 @@ def setUp(self):
         self.pin8 = '45678978'
 
         self.client.wipe_device()
+        reset_screenshot_capture(self.client)
 
         if VERBOSE:
             print("Setup finished")
             print("--------------")
 
     def setup_mnemonic_allallall(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic_all, pin='', passphrase_protection=False, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def setup_mnemonic_abandon(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic_abandon, pin='', passphrase_protection=False, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def setup_mnemonic_nopin_nopassphrase(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin='', passphrase_protection=False, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def setup_mnemonic_vuln20007(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic20007, pin='', passphrase_protection=False, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def setup_mnemonic_pin_nopassphrase(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=False, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def setup_mnemonic_pin_passphrase(self):
         self.client.load_device_by_mnemonic(mnemonic=self.mnemonic12, pin=self.pin4, passphrase_protection=True, label='test', language='english')
+        reset_screenshot_capture(self.client)
 
     def tearDown(self):
         self.client.close()

tests/common.py

@@ -2,8 +2,8 @@
 conftest.py -- pytest plugin for per-test OLED screenshot directories.
 
 When KEEPKEY_SCREENSHOT=1, patches KeepKeyTest.setUp to set per-test
-screenshot directories BEFORE setUp runs (so wipe_device captures go
-to the right place).
+screenshot directories. Fixture-only wipe/import captures are cleared before
+the test action begins, so they cannot masquerade as the test's OLED evidence.
 
 FAIL-FAST: If KEEPKEY_SCREENSHOT=1 and zero PNGs are captured after
 all tests complete, the session exits non-zero. This prevents silent
@@ -19,14 +19,45 @@
 
 import requests
 
+
+def pytest_collection_modifyitems(config, items):
+    """Select exact report test IDs for the screenshot-only pytest phase."""
+    if os.environ.get('KEEPKEY_SCREENSHOT') != '1':
+        return
+    encoded = os.environ.get('KEEPKEY_SCREENSHOT_TESTS', '')
+    if not encoded:
+        raise pytest.UsageError(
+            'KEEPKEY_SCREENSHOT_TESTS must list exact module::method pairs')
+    selected_pairs = set()
+    for line in encoded.splitlines():
+        if not line:
+            continue
+        parts = line.split('::')
+        if len(parts) != 2 or not all(parts):
+            raise pytest.UsageError(
+                'invalid KEEPKEY_SCREENSHOT_TESTS entry %r' % line)
+        selected_pairs.add(tuple(parts))
+    selected = []
+    deselected = []
+    for item in items:
+        module = os.path.splitext(os.path.basename(item.location[0]))[0]
+        method = getattr(item, 'originalname', None) or item.name.split('[', 1)[0]
+        if (module, method) in selected_pairs:
+            selected.append(item)
+        else:
+            deselected.append(item)
+    if deselected:
+        config.hook.pytest_deselected(items=deselected)
+    items[:] = selected
+
 if os.environ.get('KEEPKEY_SCREENSHOT') == '1':
     import common
 
     _orig_setUp = common.KeepKeyTest.setUp
 
     def _patched_setUp(self):
-        # Derive per-test screenshot directory BEFORE setUp runs,
-        # so captures during wipe_device/load_device go to the right place.
+        # Derive the per-test directory before setUp. common.KeepKeyTest.setUp
+        # clears fixture-only frames after its initial wipe completes.
         test_id = self.id()
         # pytest: "tests.test_msg_wipedevice.TestDeviceWipe.test_wipe_device"
         # unittest: "test_msg_wipedevice.TestDeviceWipe.test_wipe_device"

tests/conftest.py

@@ -34,5 +34,13 @@ def test_ethereum_getaddress(self):
         self.assertEqual(binascii.hexlify(self.client.ethereum_get_address([-9, 0])), 'f68804ac9eca9483ab4241d3e4751590d2c05102')
         self.assertEqual(binascii.hexlify(self.client.ethereum_get_address([0, 9999999])), '7a6366ecfcaf0d5dcc1539c171696c6cdd1eb8ed')
 
+    def test_ethereum_show_address(self):
+        self.requires_fullFeature()
+        self.setup_mnemonic_nopin_nopassphrase()
+        # The legacy display response is empty after the ButtonAck; address
+        # correctness is covered above. This case exists to retain the actual
+        # operation-specific OLED sequence for visual review.
+        self.client.ethereum_get_address([], show_display=True)
+
 if __name__ == '__main__':
     unittest.main()

tests/test_msg_ethereum_getaddress.py

@@ -99,11 +99,12 @@ def test_ethereum_signtx_data(self):
         self.client.apply_policy("AdvancedMode", 0)
 
     def test_ethereum_blind_sign_blocked(self):
-        """AdvancedMode OFF + contract data = device refuses to sign (7.15+).
+        """AdvancedMode OFF + contract data = device refuses to sign (7.14.2+).
 
-        OLED shows 'Blind signing disabled' then Failure.
+        OLED explains that arbitrary contract data requires AdvancedMode, then
+        the device returns the policy failure without requesting approval.
         """
-        self.requires_firmware("7.15.0")
+        self.requires_firmware("7.14.2")
         self.requires_fullFeature()
         self.setup_mnemonic_nopin_nopassphrase()
         self.client.apply_policy("AdvancedMode", 0)
@@ -121,10 +122,11 @@ def test_ethereum_blind_sign_blocked(self):
             )
             self.fail("Expected Failure -- blind signing should be blocked")
         except CallException as e:
-            self.assertIn("Blind signing disabled", str(e))
+            self.assertIn("Arbitrary contract data signing disabled by policy",
+                          str(e))
 
     def test_ethereum_blind_sign_allowed(self):
-        """AdvancedMode ON + contract data = device shows BLIND SIGNATURE warning (7.15+).
+        """AdvancedMode ON permits opaque contract-data signing (7.14.2+).
 
         OLED shows 'BLIND SIGNATURE' before signing.
         """

tests/test_msg_ethereum_signtx.py

@@ -49,6 +49,7 @@ def test_pin_passphrase(self):
 
         # Reminder UI
         assert isinstance(ret, proto.ButtonRequest)
+        self.client._capture_oled()
         self.client.debug.press_yes()
         ret = self.client.call_raw(proto.ButtonAck())
 
@@ -57,6 +58,7 @@ def test_pin_passphrase(self):
         for index, word in enumerate(mnemonic_words):
             for character in word:
                 self.assertIsInstance(ret, proto.CharacterRequest)
+                self.client._capture_oled()
                 cipher = self.client.debug.read_recovery_cipher()
 
                 encoded_character = cipher[ord(character) - 97]
@@ -107,6 +109,7 @@ def test_nopin_nopassphrase(self):
 
         # Reminder UI
         assert isinstance(ret, proto.ButtonRequest)
+        self.client._capture_oled()
         self.client.debug.press_yes()
         ret = self.client.call_raw(proto.ButtonAck())
 
@@ -115,6 +118,7 @@ def test_nopin_nopassphrase(self):
         for index, word in enumerate(mnemonic_words):
             for character in word:
                 self.assertIsInstance(ret, proto.CharacterRequest)
+                self.client._capture_oled()
                 cipher = self.client.debug.read_recovery_cipher()
 
                 encoded_character = cipher[ord(character) - 97]

tests/test_msg_recoverydevice_cipher.py

@@ -54,11 +54,8 @@ def generate_entropy(strength, internal_entropy, external_entropy):
     return entropy_stripped
 
 class TestDeviceReset(common.KeepKeyTest):
-    def test_reset_device(self):
-        # No PIN, no passphrase
+    def _reset_without_pin_and_capture(self, strength):
         external_entropy = b'zlutoucky kun upel divoke ody' * 2
-        strength = 128
-
         ret = self.client.call_raw(proto.ResetDevice(display_random=False,
                                                strength=strength,
                                                passphrase_protection=False,
@@ -77,27 +74,32 @@ def test_reset_device(self):
 
         # Explainer Dialog
         self.assertIsInstance(resp, proto.ButtonRequest)
+        self.client._capture_oled()
         self.client.debug.press_yes()
         resp = self.client.call_raw(proto.ButtonAck())
 
         mnemonic = []
         while isinstance(resp, proto.ButtonRequest):
-            mnemonic.append(self.client.debug.read_reset_word())
+            self.client._capture_oled()
+            words = self.client.debug.read_reset_word()
+            # 7.14.2's debug build exposes each physical subpage as a separate
+            # ButtonRequest for evidence capture. All subpages in one legacy
+            # word group intentionally report the same reset_word value.
+            if not mnemonic or mnemonic[-1] != words:
+                mnemonic.append(words)
             self.client.debug.press_yes()
             resp = self.client.call_raw(proto.ButtonAck())
 
         mnemonic = ' '.join(mnemonic)
 
-        # Compare that device generated proper mnemonic for given entropies
         self.assertEqual(mnemonic, expected_mnemonic)
-
         self.assertIsInstance(resp, proto.Success)
+        self.assertEqual(strength // 32 * 3, len(mnemonic.split()))
+        return self.client.call_raw(proto.Initialize())
 
-        # Compare that second pass printed out the same mnemonic once again
-        self.assertEqual(mnemonic, expected_mnemonic)
-
-        # Check if device is properly initialized
-        resp = self.client.call_raw(proto.Initialize())
+    def test_reset_device(self):
+        # 128-bit entropy produces the 12-word ceremony.
+        resp = self._reset_without_pin_and_capture(128)
         self.assertFalse(resp.pin_protection)
         self.assertFalse(resp.passphrase_protection)
 
@@ -109,6 +111,16 @@ def test_reset_device(self):
         resp = self.client.call_raw(proto.Ping(pin_protection=True))
         self.assertIsInstance(resp, proto.Success)
 
+    def test_reset_device_18_words(self):
+        resp = self._reset_without_pin_and_capture(192)
+        self.assertFalse(resp.pin_protection)
+        self.assertFalse(resp.passphrase_protection)
+
+    def test_reset_device_24_words(self):
+        resp = self._reset_without_pin_and_capture(256)
+        self.assertFalse(resp.pin_protection)
+        self.assertFalse(resp.passphrase_protection)
+
     def test_reset_device_pin(self):
         external_entropy = b'zlutoucky kun upel divoke ody' * 2
         strength = 128
@@ -131,11 +143,13 @@ def test_reset_device_pin(self):
             ret = self.client.call_raw(proto.ButtonAck())
 
         self.assertIsInstance(ret, proto.PinMatrixRequest)
+        self.client._capture_oled()
 
         # Enter PIN for first time
         pin_encoded = self.client.debug.encode_pin('654')
         ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
         self.assertIsInstance(ret, proto.PinMatrixRequest)
+        self.client._capture_oled()
 
         # Enter PIN for second time
         pin_encoded = self.client.debug.encode_pin('654')
@@ -152,12 +166,16 @@ def test_reset_device_pin(self):
 
         # Explainer Dialog
         self.assertIsInstance(resp, proto.ButtonRequest)
+        self.client._capture_oled()
         self.client.debug.press_yes()
         resp = self.client.call_raw(proto.ButtonAck())
 
         mnemonic = []
         while isinstance(resp, proto.ButtonRequest):
-            mnemonic.append(self.client.debug.read_reset_word())
+            self.client._capture_oled()
+            words = self.client.debug.read_reset_word()
+            if not mnemonic or mnemonic[-1] != words:
+                mnemonic.append(words)
             self.client.debug.press_yes()
             resp = self.client.call_raw(proto.ButtonAck())
 
@@ -206,11 +224,13 @@ def test_failed_pin(self):
             ret = self.client.call_raw(proto.ButtonAck())
 
         self.assertIsInstance(ret, proto.PinMatrixRequest)
+        self.client._capture_oled()
 
         # Enter PIN for first time
         pin_encoded = self.client.debug.encode_pin(self.pin4)
         ret = self.client.call_raw(proto.PinMatrixAck(pin=pin_encoded))
         self.assertIsInstance(ret, proto.PinMatrixRequest)
+        self.client._capture_oled()
 
         # Enter PIN for second time
         pin_encoded = self.client.debug.encode_pin(self.pin6)

tests/test_msg_resetdevice.py

@@ -35,6 +35,15 @@ def test_ripple_get_address(self):
         address = self.client.ripple_get_address(parse_path("m/44'/144'/1'/0/0"))
         self.assertEqual(address, "rJX2KwzaLJDyFhhtXKi3htaLfaUH2tptEX")
 
+    def test_ripple_show_address(self):
+        self.requires_fullFeature()
+        self.requires_firmware("6.4.0")
+        self.setup_mnemonic_allallall()
+        # The legacy display response is empty after the ButtonAck; address
+        # correctness is covered above. This case retains the actual OLED.
+        self.client.ripple_get_address(
+            parse_path("m/44'/144'/0'/0/0"), show_display=True)
+
     def test_ripple_get_address_other(self):
         self.requires_fullFeature()
         self.requires_firmware("6.4.0")
@@ -54,4 +63,3 @@ def test_ripple_get_address_other(self):
 
 if __name__ == '__main__':
     unittest.main()
-