Basic RPC ECDSA tests.

1 files changed, 82 insertions, 0 deletions

diff --git a/tests/test-rpc_pkey.c b/tests/test-rpc_pkey.c
index 6506ea6..cc2337c 100644
--- a/tests/test-rpc_pkey.c
+++ b/tests/test-rpc_pkey.c
@@ -130,6 +130,85 @@ static int test_rsa_testvec(const rsa_tc_t * const tc)
   return 1;
 }
 
+static inline const char *ecdsa_curve_name_to_string(const hal_curve_name_t curve)
+{
+  switch (curve) {
+  case HAL_CURVE_P256:  return "P-256";
+  case HAL_CURVE_P384:  return "P-384";
+  case HAL_CURVE_P521:  return "P-521";
+  default:              return "?????";
+  }
+}
+
+static int test_ecdsa_testvec(const ecdsa_tc_t * const tc)
+{
+  const hal_client_handle_t client = {0};
+  const hal_session_handle_t session = {0};
+  hal_pkey_handle_t private_key, public_key;
+  hal_error_t err;
+  size_t len;
+
+  assert(tc != NULL);
+
+  printf("Starting ECDSA %s test vector tests\n", ecdsa_curve_name_to_string(tc->curve));
+
+  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;
+
+  const uint8_t private_label[] = "ECDSA private key", public_label[] = "ECDSA public 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;
+
+  assert(len == sizeof(private_der));
+
+  if ((err = hal_rpc_pkey_load(client, session, &private_key, HAL_KEY_TYPE_EC_PRIVATE, HAL_CURVE_NONE,
+                               private_label, sizeof(private_label), private_der, sizeof(private_der),
+                               HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE)) != HAL_OK)
+    return printf("Could not load private key into RPC: %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)
+    return printf("Could not DER encode public key from test vector: %s\n", hal_error_string(err)), 0;
+
+  assert(len == sizeof(public_der));
+
+  if ((err = hal_rpc_pkey_load(client, session, &public_key, HAL_KEY_TYPE_EC_PUBLIC, HAL_CURVE_NONE,
+                               public_label, sizeof(public_label), public_der, sizeof(public_der),
+                               HAL_KEY_FLAG_USAGE_DIGITALSIGNATURE)) != HAL_OK)
+    return printf("Could not load public key into RPC: %s\n", hal_error_string(err)), 0;
+
+  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;
+
+  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_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_delete(private_key)) != HAL_OK)
+    return printf("Could not delete private key: %s\n", hal_error_string(err)), 0;
+
+  if ((err = hal_rpc_pkey_delete(public_key)) != HAL_OK)
+    return printf("Could not delete public key: %s\n", hal_error_string(err)), 0;
+
+  printf("OK\n");
+  return 1;
+}
+
 int main (int argc, char *argv[])
 {
   rpc_client_init(RPC_LOCAL);
@@ -140,6 +219,9 @@ int main (int argc, char *argv[])
   for (int i = 0; i < (sizeof(rsa_tc)/sizeof(*rsa_tc)); i++)
     ok &= test_rsa_testvec(&rsa_tc[i]);
 
+  for (int i = 0; i < (sizeof(ecdsa_tc)/sizeof(*ecdsa_tc)); i++)
+    ok &= test_ecdsa_testvec(&ecdsa_tc[i]);
+
   return !ok;
 }