Debug keystore attribute code; handle name properly in ks_index_replace().

hal_rpc_pkey_match() still untested.

1 files changed, 275 insertions, 165 deletions

diff --git a/tests/test-rpc_pkey.c b/tests/test-rpc_pkey.c
index efc0cf1..a82978d 100644
--- a/tests/test-rpc_pkey.c
+++ b/tests/test-rpc_pkey.c
@@ -44,6 +44,8 @@
 #include "test-rsa.h"
 #include "test-ecdsa.h"
 
+#define lose(...) do { printf(__VA_ARGS__); goto fail; } while (0)
+
 static inline const char *ecdsa_curve_to_string(const hal_curve_name_t curve)
 {
   switch (curve) {
@@ -54,269 +56,377 @@ static inline const char *ecdsa_curve_to_string(const hal_curve_name_t curve)
   }
 }
 
+static int test_attributes(const hal_pkey_handle_t pkey)
+{
+  static const size_t sizes[] = { 32, 100, 260, 1000, 2000, 2048, 0 };
+  hal_error_t err;
+  size_t n;
+
+  for (const size_t *size = sizes; *size; size++) {
+    uint8_t buf_1[*size], buf_2[*size];
+    memset(buf_1, 0x55, sizeof(buf_1));
+    snprintf((char *) buf_1, sizeof(buf_1), "Test attribute %lu", (unsigned long) *size);
+
+    if ((err = hal_rpc_pkey_set_attribute(pkey, *size, buf_1, sizeof(buf_1))) != HAL_OK)
+      lose("Could not set attribute %lu: %s\n",
+           (unsigned long) *size, hal_error_string(err));
+
+    if ((err = hal_rpc_pkey_get_attribute(pkey, *size, buf_2, &n, sizeof(buf_2))) != HAL_OK)
+      lose("Could not get attribute %lu: %s\n",
+           (unsigned long) *size, hal_error_string(err));
+
+    if (n != *size)
+      lose("Unexpected size returned for attribute %lu: %lu\n",
+           (unsigned long) *size, (unsigned long) n);
+
+    if ((err = hal_rpc_pkey_delete_attribute(pkey, *size)) != HAL_OK)
+      lose("Could not delete attribute %lu: %s\n",
+           (unsigned long) *size, hal_error_string(err));
+
+    if ((err = hal_rpc_pkey_set_attribute(pkey, *size, buf_1, sizeof(buf_1))) != HAL_OK)
+      lose("Could not (re)set attribute %lu: %s\n",
+           (unsigned long) *size, hal_error_string(err));
+  }
+
+#warning Still need something to test hal_rpc_pkey_match()
+
+  return 1;
+
+ fail:
+  return 0;
+}
+
 static int test_rsa_testvec(const rsa_tc_t * const tc, hal_key_flags_t flags)
 {
-  const hal_client_handle_t client = {0};
-  const hal_session_handle_t session = {0};
-  hal_pkey_handle_t private_key, public_key;
+  const hal_client_handle_t client = {HAL_HANDLE_NONE};
+  const hal_session_handle_t session = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t private_key = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t public_key = {HAL_HANDLE_NONE};
   hal_error_t err;
   size_t len;
 
   assert(tc != NULL);
 
-  flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
+  {
+    flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
 
-  printf("Starting %lu-bit RSA test vector tests, flags 0x%lx\n",
-         (unsigned long) tc->size, (unsigned long) flags);
+    printf("Starting %lu-bit RSA test vector tests, flags 0x%lx\n",
+           (unsigned long) tc->size, (unsigned long) flags);
 
-  uint8_t tc_keybuf[hal_rsa_key_t_size];
-  hal_rsa_key_t *tc_key = NULL;
+    uint8_t tc_keybuf[hal_rsa_key_t_size];
+    hal_rsa_key_t *tc_key = NULL;
 
-  if ((err = hal_rsa_key_load_private(&tc_key,
-                                      tc_keybuf, sizeof(tc_keybuf),
-                                      tc->n.val,  tc->n.len,
-                                      tc->e.val,  tc->e.len,
-                                      tc->d.val,  tc->d.len,
-                                      tc->p.val,  tc->p.len,
-                                      tc->q.val,  tc->q.len,
-                                      tc->u.val,  tc->u.len,
-                                      tc->dP.val, tc->dP.len,
-                                      tc->dQ.val, tc->dQ.len)) != HAL_OK)
-    return printf("Could not load RSA private key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rsa_key_load_private(&tc_key,
+                                        tc_keybuf, sizeof(tc_keybuf),
+                                        tc->n.val,  tc->n.len,
+                                        tc->e.val,  tc->e.len,
+                                        tc->d.val,  tc->d.len,
+                                        tc->p.val,  tc->p.len,
+                                        tc->q.val,  tc->q.len,
+                                        tc->u.val,  tc->u.len,
+                                        tc->dP.val, tc->dP.len,
+                                        tc->dQ.val, tc->dQ.len)) != HAL_OK)
+      lose("Could not load RSA private key from test vector: %s\n", hal_error_string(err));
 
-  hal_uuid_t private_name, public_name;
+    hal_uuid_t private_name, public_name;
 
-  uint8_t private_der[hal_rsa_private_key_to_der_len(tc_key)];
-  uint8_t public_der[hal_rsa_public_key_to_der_len(tc_key)];
+    uint8_t private_der[hal_rsa_private_key_to_der_len(tc_key)];
+    uint8_t public_der[hal_rsa_public_key_to_der_len(tc_key)];
 
-  if ((err = hal_rsa_private_key_to_der(tc_key, private_der, &len, sizeof(private_der))) != HAL_OK)
-    return printf("Could not DER encode private key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rsa_private_key_to_der(tc_key, private_der, &len, sizeof(private_der))) != HAL_OK)
+      lose("Could not DER encode private key from test vector: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(private_der));
+    assert(len == sizeof(private_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &private_key, HAL_KEY_TYPE_RSA_PRIVATE, HAL_CURVE_NONE,
-                               &private_name, private_der, sizeof(private_der), flags)) != HAL_OK)
-    return printf("Could not load private key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &private_key, HAL_KEY_TYPE_RSA_PRIVATE, HAL_CURVE_NONE,
+                                 &private_name, private_der, sizeof(private_der), flags)) != HAL_OK)
+      lose("Could not load private key into RPC: %s\n", hal_error_string(err));
 
-  if ((err = hal_rsa_public_key_to_der(tc_key, public_der, &len, sizeof(public_der))) != HAL_OK)
-    return printf("Could not DER encode public key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rsa_public_key_to_der(tc_key, public_der, &len, sizeof(public_der))) != HAL_OK)
+      lose("Could not DER encode public key from test vector: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(public_der));
+    assert(len == sizeof(public_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_RSA_PUBLIC, HAL_CURVE_NONE,
-                               &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
-    return printf("Could not load public key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_RSA_PUBLIC, HAL_CURVE_NONE,
+                                 &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
+      lose("Could not load public key into RPC: %s\n", hal_error_string(err));
 
-  uint8_t sig[tc->s.len];
+    uint8_t sig[tc->s.len];
 
-  /*
-   * Raw RSA test cases include PKCS #1.5 padding, we need to drill down to the DigestInfo.
-   */
-  assert(tc->m.len > 4 && tc->m.val[0] == 0x00 && tc->m.val[1] == 0x01 && tc->m.val[2] == 0xff);
-  const uint8_t *digestinfo = memchr(tc->m.val + 2, 0x00, tc->m.len - 2);
-  assert(digestinfo != NULL);
-  const size_t digestinfo_len = tc->m.val + tc->m.len - ++digestinfo;
+    /*
+     * Raw RSA test cases include PKCS #1.5 padding, we need to drill down to the DigestInfo.
+     */
+    assert(tc->m.len > 4 && tc->m.val[0] == 0x00 && tc->m.val[1] == 0x01 && tc->m.val[2] == 0xff);
+    const uint8_t *digestinfo = memchr(tc->m.val + 2, 0x00, tc->m.len - 2);
+    assert(digestinfo != NULL);
+    const size_t digestinfo_len = tc->m.val + tc->m.len - ++digestinfo;
 
-  if ((err = hal_rpc_pkey_sign(session, private_key, hal_hash_handle_none,
-                               digestinfo, digestinfo_len, sig, &len, sizeof(sig))) != HAL_OK)
-    return printf("Could not sign: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_sign(private_key, hal_hash_handle_none,
+                                 digestinfo, digestinfo_len, sig, &len, sizeof(sig))) != HAL_OK)
+      lose("Could not sign: %s\n", hal_error_string(err));
 
-  if (tc->s.len != len || memcmp(sig, tc->s.val, tc->s.len) != 0)
-    return printf("MISMATCH\n"), 0;
+    if (tc->s.len != len || memcmp(sig, tc->s.val, tc->s.len) != 0)
+      lose("MISMATCH\n");
 
-  if ((err = hal_rpc_pkey_verify(session, public_key, hal_hash_handle_none,
-                                 digestinfo, digestinfo_len, tc->s.val, tc->s.len)) != HAL_OK)
-    return printf("Could not verify: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_verify(public_key, hal_hash_handle_none,
+                                   digestinfo, digestinfo_len, tc->s.val, tc->s.len)) != HAL_OK)
+      lose("Could not verify: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
-    return printf("Could not delete private key: %s\n", hal_error_string(err)), 0;
+    if (!test_attributes(private_key) || !test_attributes(public_key))
+      goto fail;
 
-  if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
-    return printf("Could not delete public key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+      lose("Could not delete private key: %s\n", hal_error_string(err));
 
-  printf("OK\n");
-  return 1;
+    if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+      lose("Could not delete public key: %s\n", hal_error_string(err));
+
+    printf("OK\n");
+    return 1;
+  }
+
+ fail:
+  if (private_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+    printf("Warning: could not delete private key: %s\n", hal_error_string(err));
+
+  if (public_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+    printf("Warning: could not delete public key: %s\n", hal_error_string(err));
+
+  return 0;
 }
 
 static int test_ecdsa_testvec(const ecdsa_tc_t * const tc, hal_key_flags_t flags)
 {
-  const hal_client_handle_t client = {0};
-  const hal_session_handle_t session = {0};
-  hal_pkey_handle_t private_key, public_key;
+  const hal_client_handle_t client = {HAL_HANDLE_NONE};
+  const hal_session_handle_t session = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t private_key = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t public_key = {HAL_HANDLE_NONE};
   hal_error_t err;
   size_t len;
 
   assert(tc != NULL);
 
-  flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
+  {
+    flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
 
-  printf("Starting ECDSA %s test vector tests, flags 0x%lx\n",
-         ecdsa_curve_to_string(tc->curve), (unsigned long) flags);
+    printf("Starting ECDSA %s test vector tests, flags 0x%lx\n",
+           ecdsa_curve_to_string(tc->curve), (unsigned long) flags);
 
-  uint8_t tc_keybuf[hal_ecdsa_key_t_size];
-  hal_ecdsa_key_t *tc_key = NULL;
+    uint8_t tc_keybuf[hal_ecdsa_key_t_size];
+    hal_ecdsa_key_t *tc_key = NULL;
 
-  if ((err = hal_ecdsa_key_load_private(&tc_key, tc_keybuf, sizeof(tc_keybuf), tc->curve,
-                                        tc->Qx, tc->Qx_len, tc->Qy, tc->Qy_len,
-                                        tc->d,  tc->d_len)) != HAL_OK)
-    return printf("Could not load ECDSA private key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_ecdsa_key_load_private(&tc_key, tc_keybuf, sizeof(tc_keybuf), tc->curve,
+                                          tc->Qx, tc->Qx_len, tc->Qy, tc->Qy_len,
+                                          tc->d,  tc->d_len)) != HAL_OK)
+      lose("Could not load ECDSA private key from test vector: %s\n", hal_error_string(err));
 
-  hal_uuid_t private_name, public_name;
+    hal_uuid_t private_name, public_name;
 
-  uint8_t private_der[hal_ecdsa_private_key_to_der_len(tc_key)];
-  uint8_t public_der[hal_ecdsa_public_key_to_der_len(tc_key)];
+    uint8_t private_der[hal_ecdsa_private_key_to_der_len(tc_key)];
+    uint8_t public_der[hal_ecdsa_public_key_to_der_len(tc_key)];
 
-  if ((err = hal_ecdsa_private_key_to_der(tc_key, private_der, &len, sizeof(private_der))) != HAL_OK)
-    return printf("Could not DER encode private key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_ecdsa_private_key_to_der(tc_key, private_der, &len, sizeof(private_der))) != HAL_OK)
+      lose("Could not DER encode private key from test vector: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(private_der));
+    assert(len == sizeof(private_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &private_key, HAL_KEY_TYPE_EC_PRIVATE, tc->curve,
-                               &private_name, private_der, sizeof(private_der), flags)) != HAL_OK)
-    return printf("Could not load private key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &private_key, HAL_KEY_TYPE_EC_PRIVATE, tc->curve,
+                                 &private_name, private_der, sizeof(private_der), flags)) != HAL_OK)
+      lose("Could not load private key into RPC: %s\n", hal_error_string(err));
 
-  if ((err = hal_ecdsa_public_key_to_der(tc_key, public_der, &len, sizeof(public_der))) != HAL_OK)
-    return printf("Could not DER encode public key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_ecdsa_public_key_to_der(tc_key, public_der, &len, sizeof(public_der))) != HAL_OK)
+      lose("Could not DER encode public key from test vector: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(public_der));
+    assert(len == sizeof(public_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_EC_PUBLIC, tc->curve,
-                               &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
-    return printf("Could not load public key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_EC_PUBLIC, tc->curve,
+                                 &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
+      lose("Could not load public key into RPC: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_verify(session, public_key, hal_hash_handle_none,
-                                 tc->H, tc->H_len, tc->sig, tc->sig_len)) != HAL_OK)
-    return printf("Could not verify signature from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_verify(public_key, hal_hash_handle_none,
+                                   tc->H, tc->H_len, tc->sig, tc->sig_len)) != HAL_OK)
+      lose("Could not verify signature from test vector: %s\n", hal_error_string(err));
 
-  uint8_t sig[tc->sig_len + 4];
+    uint8_t sig[tc->sig_len + 4];
 
-  if ((err = hal_rpc_pkey_sign(session, private_key, hal_hash_handle_none,
-                               tc->H, tc->H_len, sig, &len, sizeof(sig))) != HAL_OK)
-    return printf("Could not sign: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_sign(private_key, hal_hash_handle_none,
+                                 tc->H, tc->H_len, sig, &len, sizeof(sig))) != HAL_OK)
+      lose("Could not sign: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_verify(session, public_key, hal_hash_handle_none,
-                                 tc->H, tc->H_len, sig, len)) != HAL_OK)
-    return printf("Could not verify own signature: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_verify(public_key, hal_hash_handle_none,
+                                   tc->H, tc->H_len, sig, len)) != HAL_OK)
+      lose("Could not verify own signature: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
-    return printf("Could not delete private key: %s\n", hal_error_string(err)), 0;
+    if (!test_attributes(private_key) || !test_attributes(public_key))
+      goto fail;
 
-  if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
-    return printf("Could not delete public key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+      lose("Could not delete private key: %s\n", hal_error_string(err));
 
-  printf("OK\n");
-  return 1;
+    if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+      lose("Could not delete public key: %s\n", hal_error_string(err));
+
+    printf("OK\n");
+    return 1;
+  }
+
+ fail:
+  if (private_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+    printf("Warning: could not delete private key: %s\n", hal_error_string(err));
+
+  if (public_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+    printf("Warning: could not delete public key: %s\n", hal_error_string(err));
+
+  return 0;
 }
 
 static int test_rsa_generate(const rsa_tc_t * const tc, hal_key_flags_t flags)
 {
-  const hal_client_handle_t client = {0};
-  const hal_session_handle_t session = {0};
-  hal_pkey_handle_t private_key, public_key;
+  const hal_client_handle_t client = {HAL_HANDLE_NONE};
+  const hal_session_handle_t session = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t private_key = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t public_key = {HAL_HANDLE_NONE};
   hal_error_t err;
   size_t len;
 
   assert(tc != NULL);
 
-  flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
+  {
+    flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
 
-  printf("Starting %lu-bit RSA key generation tests, flags 0x%lx\n",
-         (unsigned long) tc->size, (unsigned long) flags);
+    printf("Starting %lu-bit RSA key generation tests, flags 0x%lx\n",
+           (unsigned long) tc->size, (unsigned long) flags);
 
-  hal_uuid_t private_name, public_name;
+    hal_uuid_t private_name, public_name;
 
-  if ((err = hal_rpc_pkey_generate_rsa(client, session, &private_key, &private_name,
-                                       tc->size, tc->e.val, tc->e.len, flags)) != HAL_OK)
-    return printf("Could not generate RSA private key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_generate_rsa(client, session, &private_key, &private_name,
+                                         tc->size, tc->e.val, tc->e.len, flags)) != HAL_OK)
+      lose("Could not generate RSA private key: %s\n", hal_error_string(err));
 
-  uint8_t public_der[hal_rpc_pkey_get_public_key_len(private_key)];
+    uint8_t public_der[hal_rpc_pkey_get_public_key_len(private_key)];
 
-  if ((err = hal_rpc_pkey_get_public_key(private_key, public_der, &len, sizeof(public_der))) != HAL_OK)
-    return printf("Could not DER encode RPC RSA public key from RPC RSA private key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_get_public_key(private_key, public_der, &len, sizeof(public_der))) != HAL_OK)
+      lose("Could not DER encode RPC RSA public key from RPC RSA private key: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(public_der));
+    assert(len == sizeof(public_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_RSA_PUBLIC, HAL_CURVE_NONE,
-                               &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
-    return printf("Could not load public key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_RSA_PUBLIC, HAL_CURVE_NONE,
+                                 &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
+      lose("Could not load public key into RPC: %s\n", hal_error_string(err));
 
-  uint8_t sig[tc->s.len];
+    uint8_t sig[tc->s.len];
 
-  /*
-   * Raw RSA test cases include PKCS #1.5 padding, we need to drill down to the DigestInfo.
-   */
-  assert(tc->m.len > 4 && tc->m.val[0] == 0x00 && tc->m.val[1] == 0x01 && tc->m.val[2] == 0xff);
-  const uint8_t *digestinfo = memchr(tc->m.val + 2, 0x00, tc->m.len - 2);
-  assert(digestinfo != NULL);
-  const size_t digestinfo_len = tc->m.val + tc->m.len - ++digestinfo;
+    /*
+     * Raw RSA test cases include PKCS #1.5 padding, we need to drill down to the DigestInfo.
+     */
+    assert(tc->m.len > 4 && tc->m.val[0] == 0x00 && tc->m.val[1] == 0x01 && tc->m.val[2] == 0xff);
+    const uint8_t *digestinfo = memchr(tc->m.val + 2, 0x00, tc->m.len - 2);
+    assert(digestinfo != NULL);
+    const size_t digestinfo_len = tc->m.val + tc->m.len - ++digestinfo;
 
-  if ((err = hal_rpc_pkey_sign(session, private_key, hal_hash_handle_none,
-                               digestinfo, digestinfo_len, sig, &len, sizeof(sig))) != HAL_OK)
-    return printf("Could not sign: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_sign(private_key, hal_hash_handle_none,
+                                 digestinfo, digestinfo_len, sig, &len, sizeof(sig))) != HAL_OK)
+      lose("Could not sign: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_verify(session, public_key, hal_hash_handle_none,
-                                 digestinfo, digestinfo_len, sig, len)) != HAL_OK)
-    return printf("Could not verify: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_verify(public_key, hal_hash_handle_none,
+                                   digestinfo, digestinfo_len, sig, len)) != HAL_OK)
+      lose("Could not verify: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
-    return printf("Could not delete private key: %s\n", hal_error_string(err)), 0;
+    if (!test_attributes(private_key) || !test_attributes(public_key))
+      goto fail;
 
-  if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
-    return printf("Could not delete public key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+      lose("Could not delete private key: %s\n", hal_error_string(err));
 
-  printf("OK\n");
-  return 1;
+    if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+      lose("Could not delete public key: %s\n", hal_error_string(err));
+
+    printf("OK\n");
+    return 1;
+  }
+
+ fail:
+  if (private_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+    printf("Warning: could not delete private key: %s\n", hal_error_string(err));
+
+  if (public_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+    printf("Warning: could not delete public key: %s\n", hal_error_string(err));
+
+  return 0;
 }
 
 static int test_ecdsa_generate(const ecdsa_tc_t * const tc, hal_key_flags_t flags)
 {
-  const hal_client_handle_t client = {0};
-  const hal_session_handle_t session = {0};
-  hal_pkey_handle_t private_key, public_key;
+  const hal_client_handle_t client = {HAL_HANDLE_NONE};
+  const hal_session_handle_t session = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t private_key = {HAL_HANDLE_NONE};
+  hal_pkey_handle_t public_key = {HAL_HANDLE_NONE};
   hal_error_t err;
   size_t len;
 
   assert(tc != NULL);
 
-  flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
+  {
+    flags |= HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE;
 
-  printf("Starting ECDSA %s key generation tests, flags 0x%lx\n",
-         ecdsa_curve_to_string(tc->curve), (unsigned long) flags);
+    printf("Starting ECDSA %s key generation tests, flags 0x%lx\n",
+           ecdsa_curve_to_string(tc->curve), (unsigned long) flags);
 
-  hal_uuid_t private_name, public_name;
+    hal_uuid_t private_name, public_name;
 
-  if ((err = hal_rpc_pkey_generate_ec(client, session, &private_key, &private_name, tc->curve, flags)) != HAL_OK)
-    return printf("Could not generate EC key pair: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_generate_ec(client, session, &private_key, &private_name, tc->curve, flags)) != HAL_OK)
+      lose("Could not generate EC key pair: %s\n", hal_error_string(err));
 
-  uint8_t public_der[hal_rpc_pkey_get_public_key_len(private_key)];
+    uint8_t public_der[hal_rpc_pkey_get_public_key_len(private_key)];
 
-  if ((err = hal_rpc_pkey_get_public_key(private_key, public_der, &len, sizeof(public_der))) != HAL_OK)
-    return printf("Could not DER encode public key from test vector: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_get_public_key(private_key, public_der, &len, sizeof(public_der))) != HAL_OK)
+      lose("Could not DER encode public key from test vector: %s\n", hal_error_string(err));
 
-  assert(len == sizeof(public_der));
+    assert(len == sizeof(public_der));
 
-  if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_EC_PUBLIC, tc->curve,
-                               &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
-    return printf("Could not load public key into RPC: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_EC_PUBLIC, tc->curve,
+                                 &public_name, public_der, sizeof(public_der), flags)) != HAL_OK)
+      lose("Could not load public key into RPC: %s\n", hal_error_string(err));
 
-  uint8_t sig[tc->sig_len + 4];
+    uint8_t sig[tc->sig_len + 4];
 
-  if ((err = hal_rpc_pkey_sign(session, private_key, hal_hash_handle_none,
-                               tc->H, tc->H_len, sig, &len, sizeof(sig))) != HAL_OK)
-    return printf("Could not sign: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_sign(private_key, hal_hash_handle_none,
+                                 tc->H, tc->H_len, sig, &len, sizeof(sig))) != HAL_OK)
+      lose("Could not sign: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_verify(session, public_key, hal_hash_handle_none,
-                                 tc->H, tc->H_len, sig, len)) != HAL_OK)
-    return printf("Could not verify own signature: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_verify(public_key, hal_hash_handle_none,
+                                   tc->H, tc->H_len, sig, len)) != HAL_OK)
+      lose("Could not verify own signature: %s\n", hal_error_string(err));
 
-  if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
-    return printf("Could not delete private key: %s\n", hal_error_string(err)), 0;
+    if (!test_attributes(private_key) || !test_attributes(public_key))
+      goto fail;
 
-  if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
-    return printf("Could not delete public key: %s\n", hal_error_string(err)), 0;
+    if ((err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+      lose("Could not delete private key: %s\n", hal_error_string(err));
 
-  printf("OK\n");
-  return 1;
+    if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+      lose("Could not delete public key: %s\n", hal_error_string(err));
+
+    printf("OK\n");
+    return 1;
+  }
+
+ fail:
+  if (private_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(private_key)) != HAL_OK)
+    printf("Warning: could not delete private key: %s\n", hal_error_string(err));
+
+  if (public_key.handle != HAL_HANDLE_NONE &&
+      (err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+    printf("Warning: could not delete public key: %s\n", hal_error_string(err));
+
+  return 0;
 }
 
 int main (int argc, char *argv[])