tests: unit test for ResetDevice_skipbackup (and subsequent BackupDevice)

tests/device_tests/common.py

@@ -19,6 +19,8 @@
 from __future__ import print_function
 
 import unittest
+import hashlib
+
 from trezorlib.client import TrezorClient, TrezorDebugClient
 from trezorlib import tx_api
 import config
@@ -28,6 +30,7 @@ tx_api.cache_dir = '../txcache'
 
 
 class TrezorTest(unittest.TestCase):
+
     def setUp(self):
         transport = config.TRANSPORT(*config.TRANSPORT_ARGS, **config.TRANSPORT_KWARGS)
         if hasattr(config, 'DEBUG_TRANSPORT'):
@@ -68,3 +71,32 @@ class TrezorTest(unittest.TestCase):
 
     def tearDown(self):
         self.client.close()
+
+
+def generate_entropy(strength, internal_entropy, external_entropy):
+    '''
+    strength - length of produced seed. One of 128, 192, 256
+    random - binary stream of random data from external HRNG
+    '''
+    if strength not in (128, 192, 256):
+        raise Exception("Invalid strength")
+
+    if not internal_entropy:
+        raise Exception("Internal entropy is not provided")
+
+    if len(internal_entropy) < 32:
+        raise Exception("Internal entropy too short")
+
+    if not external_entropy:
+        raise Exception("External entropy is not provided")
+
+    if len(external_entropy) < 32:
+        raise Exception("External entropy too short")
+
+    entropy = hashlib.sha256(internal_entropy + external_entropy).digest()
+    entropy_stripped = entropy[:strength // 8]
+
+    if len(entropy_stripped) * 8 != strength:
+        raise Exception("Entropy length mismatch")
+
+    return entropy_stripped

tests/device_tests/test_msg_resetdevice.py

@@ -17,45 +17,16 @@
 # along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
 import unittest
-import hashlib
 import common
 
 from trezorlib import messages_pb2 as proto
 from mnemonic import Mnemonic
 
 
-def generate_entropy(strength, internal_entropy, external_entropy):
-    '''
-    strength - length of produced seed. One of 128, 192, 256
-    random - binary stream of random data from external HRNG
-    '''
-    if strength not in (128, 192, 256):
-        raise Exception("Invalid strength")
-
-    if not internal_entropy:
-        raise Exception("Internal entropy is not provided")
-
-    if len(internal_entropy) < 32:
-        raise Exception("Internal entropy too short")
-
-    if not external_entropy:
-        raise Exception("External entropy is not provided")
-
-    if len(external_entropy) < 32:
-        raise Exception("External entropy too short")
-
-    entropy = hashlib.sha256(internal_entropy + external_entropy).digest()
-    entropy_stripped = entropy[:strength // 8]
-
-    if len(entropy_stripped) * 8 != strength:
-        raise Exception("Entropy length mismatch")
-
-    return entropy_stripped
-
-
 class TestDeviceReset(common.TrezorTest):
 
     def test_reset_device(self):
+
         # No PIN, no passphrase
         external_entropy = b'zlutoucky kun upel divoke ody' * 2
         strength = 128
@@ -75,7 +46,7 @@ class TestDeviceReset(common.TrezorTest):
         ret = self.client.call_raw(proto.EntropyAck(entropy=external_entropy))
 
         # Generate mnemonic locally
-        entropy = generate_entropy(strength, internal_entropy, external_entropy)
+        entropy = common.generate_entropy(strength, internal_entropy, external_entropy)
         expected_mnemonic = Mnemonic('english').to_mnemonic(entropy)
 
         mnemonic = []
@@ -106,6 +77,8 @@ class TestDeviceReset(common.TrezorTest):
 
         # Check if device is properly initialized
         resp = self.client.call_raw(proto.Initialize())
+        self.assertTrue(resp.initialized)
+        self.assertFalse(resp.needs_backup)
         self.assertFalse(resp.pin_protection)
         self.assertFalse(resp.passphrase_protection)
 
@@ -151,7 +124,7 @@ class TestDeviceReset(common.TrezorTest):
         ret = self.client.call_raw(proto.EntropyAck(entropy=external_entropy))
 
         # Generate mnemonic locally
-        entropy = generate_entropy(strength, internal_entropy, external_entropy)
+        entropy = common.generate_entropy(strength, internal_entropy, external_entropy)
         expected_mnemonic = Mnemonic('english').to_mnemonic(entropy)
 
         mnemonic = []
@@ -182,6 +155,8 @@ class TestDeviceReset(common.TrezorTest):
 
         # Check if device is properly initialized
         resp = self.client.call_raw(proto.Initialize())
+        self.assertTrue(resp.initialized)
+        self.assertFalse(resp.needs_backup)
         self.assertTrue(resp.pin_protection)
         self.assertTrue(resp.passphrase_protection)
 

tests/device_tests/test_msg_resetdevice_skipbackup.py

@@ -0,0 +1,98 @@
+# This file is part of the TREZOR project.
+#
+# Copyright (C) 2012-2016 Marek Palatinus <slush@satoshilabs.com>
+# Copyright (C) 2012-2016 Pavol Rusnak <stick@satoshilabs.com>
+#
+# This library is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this library.  If not, see <http://www.gnu.org/licenses/>.
+
+import unittest
+import common
+
+from trezorlib import messages_pb2 as proto
+from mnemonic import Mnemonic
+
+
+class TestDeviceResetSkipBackup(common.TrezorTest):
+
+    def test_reset_device_skip_backup(self):
+
+        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,
+            pin_protection=False,
+            language='english',
+            label='test',
+            skip_backup=True
+        ))
+
+        # Provide entropy
+        self.assertIsInstance(ret, proto.EntropyRequest)
+        internal_entropy = self.client.debug.read_reset_entropy()
+        ret = self.client.call_raw(proto.EntropyAck(entropy=external_entropy))
+        self.assertIsInstance(ret, proto.Success)
+
+        # Check if device is properly initialized
+        resp = self.client.call_raw(proto.Initialize())
+        self.assertTrue(resp.initialized)
+        self.assertTrue(resp.needs_backup)
+
+        # Generate mnemonic locally
+        entropy = common.generate_entropy(strength, internal_entropy, external_entropy)
+        expected_mnemonic = Mnemonic('english').to_mnemonic(entropy)
+
+        # start Backup workflow
+        ret = self.client.call_raw(proto.BackupDevice())
+
+        mnemonic = []
+        for _ in range(strength // 32 * 3):
+            self.assertIsInstance(ret, proto.ButtonRequest)
+            mnemonic.append(self.client.debug.read_reset_word())
+            self.client.debug.press_yes()
+            self.client.call_raw(proto.ButtonAck())
+
+        mnemonic = ' '.join(mnemonic)
+
+        # Compare that device generated proper mnemonic for given entropies
+        self.assertEqual(mnemonic, expected_mnemonic)
+
+        mnemonic = []
+        for _ in range(strength // 32 * 3):
+            self.assertIsInstance(ret, proto.ButtonRequest)
+            mnemonic.append(self.client.debug.read_reset_word())
+            self.client.debug.press_yes()
+            resp = self.client.call_raw(proto.ButtonAck())
+
+        self.assertIsInstance(resp, proto.Success)
+
+        mnemonic = ' '.join(mnemonic)
+
+        # Compare that second pass printed out the same mnemonic once again
+        self.assertEqual(mnemonic, expected_mnemonic)
+
+        # start backup again - should fail
+        ret = self.client.call_raw(proto.BackupDevice())
+        self.assertIsInstance(ret, proto.Failure)
+
+    def test_initialized_device_backup_fail(self):
+        self.setup_mnemonic_nopin_nopassphrase()
+        ret = self.client.call_raw(proto.BackupDevice())
+        self.assertIsInstance(ret, proto.Failure)
+
+
+if __name__ == '__main__':
+    unittest.main()

trezorlib/types_pb2.py

@@ -1,7 +1,7 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: types.proto
 # libprotoc 3.3.0
-# trezor-common e04ecf819bf5e00413408b735f446431e28428e1
+# trezor-common 654ee5d8ec575331b6be15343617a8fcfdd66cdd
 
 import sys
 _b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))