Merge branch 'pymux' into hw_ecdsa_p256

1 files changed, 46 insertions, 5 deletions

diff --git a/unit-tests.py b/unit-tests.py
index a8779c5..c1d0d44 100644
--- a/unit-tests.py
+++ b/unit-tests.py
@@ -39,6 +39,7 @@ LibHAL unit tests, using libhal.py and the Python unit_test framework.
 
 import unittest
 import datetime
+import logging
 import sys
 
 from libhal import *
@@ -66,10 +67,7 @@ except ImportError:
     ecdsa_loaded = False
 
 
-def log(msg):
-    if not args.quiet:
-        sys.stderr.write(msg)
-        sys.stderr.write("\n")
+logger = logging.getLogger("unit-tests")
 
 
 def main():
@@ -77,12 +75,14 @@ def main():
     global args
     args = parse_arguments(argv[1:])
     argv = argv[:1] + args.only_test
+    logging.basicConfig(level = logging.DEBUG if args.debug else logging.INFO)
     unittest.main(verbosity = 1 if args.quiet else 2, argv = argv, catchbreak = True, testRunner = TextTestRunner)
 
 def parse_arguments(argv = ()):
     from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
     parser = ArgumentParser(description = __doc__, formatter_class = ArgumentDefaultsHelpFormatter)
     parser.add_argument("--quiet",      action = "store_true",          help = "suppress chatter")
+    parser.add_argument("--debug",      action = "store_true",          help = "debug-level logging")
     parser.add_argument("--wheel-pin",  default = "fnord",              help = "PIN for wheel user")
     parser.add_argument("--so-pin",     default = "fnord",              help = "PIN for security officer")
     parser.add_argument("--user-pin",   default = "fnord",              help = "PIN for normal user")
@@ -125,6 +125,12 @@ class TextTestResult(unittest.TextTestResult):
             self.stream.flush()
         super(TextTestResult, self).addSuccess(test)
 
+    def addError(self, test, err):
+        if self.showAll:
+            self.stream.write("exception {!s} ".format(err[0].__name__)) # err[1]
+            self.stream.flush()
+        super(TextTestResult, self).addError(test, err)
+
 class TextTestRunner(unittest.TextTestRunner):
     resultclass = TextTestResult
 
@@ -335,93 +341,123 @@ class TestPKeyHashing(TestCaseLoggedIn):
         k1.verify(signature = sig, hash = self.h(alg, mixed_mode = True))
         k2.verify(signature = sig, hash = self.h(alg, mixed_mode = True))
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_1024_sha256_data(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA256, 1024, self.sign_verify_data)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_2048_sha384_data(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA384, 2048, self.sign_verify_data)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_4096_sha512_data(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA512, 4096, self.sign_verify_data)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p256_sha256_data(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA256, HAL_CURVE_P256, self.sign_verify_data)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p384_sha384_data(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA384, HAL_CURVE_P384, self.sign_verify_data)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p521_sha512_data(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, HAL_CURVE_P521, self.sign_verify_data)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_1024_sha256_remote_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA256, 1024, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_2048_sha384_remote_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA384, 2048, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_4096_sha512_remote_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA512, 4096, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p256_sha256_remote_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA256, HAL_CURVE_P256, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p384_sha384_remote_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA384, HAL_CURVE_P384, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p521_sha512_remote_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, HAL_CURVE_P521, self.sign_verify_remote_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_1024_sha256_remote_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA256, 1024, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_2048_sha384_remote_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA384, 2048, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_4096_sha512_remote_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA512, 4096, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p256_sha256_remote_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA256, HAL_CURVE_P256, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p384_sha384_remote_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA384, HAL_CURVE_P384, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p521_sha512_remote_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, HAL_CURVE_P521, self.sign_verify_remote_local)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_1024_sha256_local_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA256, 1024, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_2048_sha384_local_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA384, 2048, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_4096_sha512_local_remote(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA512, 4096, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p256_sha256_local_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA256, HAL_CURVE_P256, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p384_sha384_local_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA384, HAL_CURVE_P384, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p521_sha512_local_remote(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, HAL_CURVE_P521, self.sign_verify_local_remote)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_1024_sha256_local_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA256, 1024, self.sign_verify_local_local)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_2048_sha384_local_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA384, 2048, self.sign_verify_local_local)
 
+    @unittest.skipUnless(pycrypto_loaded, "Requires Python Crypto package")
     def test_load_sign_verify_rsa_4096_sha512_local_local(self):
         self.load_sign_verify_rsa(HAL_DIGEST_ALGORITHM_SHA512, 4096, self.sign_verify_local_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p256_sha256_local_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA256, HAL_CURVE_P256, self.sign_verify_local_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p384_sha384_local_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA384, HAL_CURVE_P384, self.sign_verify_local_local)
 
+    @unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
     def test_load_sign_verify_ecdsa_p521_sha512_local_local(self):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, HAL_CURVE_P521, self.sign_verify_local_local)
 
@@ -494,7 +530,7 @@ class TestPKeyECDSAInterop(TestCaseLoggedIn):
         self.load_sign_verify_ecdsa(HAL_DIGEST_ALGORITHM_SHA512, SHA512, HAL_CURVE_P521)
 
 
-class TestPKeyList(TestCaseLoggedIn):
+class TestPKeyMatch(TestCaseLoggedIn):
     """
     Tests involving PKey list and match functions.
     """
@@ -594,6 +630,7 @@ class TestPKeyAttribute(TestCaseLoggedIn):
         self.load_and_fill(HAL_KEY_FLAG_TOKEN, n_attrs = 4, n_fill = 512) # [16, 1024]
 
 
+@unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
 class TestPKeyAttributeP11(TestCaseLoggedIn):
     """
     Attribute creation/lookup/deletion tests based on a PKCS #11 trace.
@@ -658,6 +695,7 @@ class TestPKeyAttributeP11(TestCaseLoggedIn):
             0x180 : "\x06\x08\x2a\x86\x48\xce\x3d\x03\x01\x07" })
 
 
+@unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
 class TestPKeyAttributeWriteSpeedToken(TestCaseLoggedIn):
     """
     Attribute speed tests.
@@ -682,6 +720,7 @@ class TestPKeyAttributeWriteSpeedToken(TestCaseLoggedIn):
     def test_set_12_attributes(self):
         self.set_attributes(12)
 
+@unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
 class TestPKeyAttributeWriteSpeedVolatile(TestCaseLoggedIn):
     """
     Attribute speed tests.
@@ -706,6 +745,7 @@ class TestPKeyAttributeWriteSpeedVolatile(TestCaseLoggedIn):
     def test_set_12_attributes(self):
         self.set_attributes(12)
 
+@unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
 class TestPKeyAttributeReadSpeedToken(TestCaseLoggedIn):
     """
     Attribute speed tests.
@@ -737,6 +777,7 @@ class TestPKeyAttributeReadSpeedToken(TestCaseLoggedIn):
     def test_get_12_attributes(self):
         self.get_attributes(12)
 
+@unittest.skipUnless(ecdsa_loaded, "Requires Python ECDSA package")
 class TestPKeyAttributeReadSpeedVolatile(TestCaseLoggedIn):
     """
     Attribute speed tests.