YACA: invalid param tests for latest key functionalities

- EC keys
- DH keys
- generation of parameters
- generation of keys from parameters
- extraction of parameters
- extraction of public (this already existed, but had no tests)

Change-Id: Ifb26eeea43923426750ed269bfe92183b5854a7d

diff --git a/src/yaca/yaca-test-common.cpp b/src/yaca/yaca-test-common.cpp
index 29f6693..3f5aa3a 100644 (file)
--- a/src/yaca/yaca-test-common.cpp
+++ b/src/yaca/yaca-test-common.cpp
@@ -102,6 +102,14 @@ KeyPtr extract_public_key(const KeyPtr &key_prv)
     return wrap_ptr(key_pub);
 }
 
+KeyPtr extract_parameters(const KeyPtr &key)
+{
+    yaca_key_h params;
+    YACA_SUCCESS(yaca_key_extract_parameters(key.get(), &params));
+    YACA_ASSERT_MSG(params != YACA_KEY_NULL, "NULL parameters extracted");
+    return wrap_ptr(params);
+}
+
 ChrPtr export_key(const KeyPtr &key,
                   yaca_key_format_e key_fmt,
                   yaca_key_file_format_e key_file_fmt,

diff --git a/src/yaca/yaca-test-common.h b/src/yaca/yaca-test-common.h
index 458d97a..eabe560 100644 (file)
--- a/src/yaca/yaca-test-common.h
+++ b/src/yaca/yaca-test-common.h
@@ -126,6 +126,8 @@ KeyPtr generate_key(yaca_key_type_e type, size_t bit_len);
 
 KeyPtr extract_public_key(const KeyPtr &key_prv);
 
+KeyPtr extract_parameters(const KeyPtr &key);
+
 ChrPtr export_key(const KeyPtr &key,
                   yaca_key_format_e key_fmt,
                   yaca_key_file_format_e key_file_fmt,

diff --git a/src/yaca/yaca-test-key.cpp b/src/yaca/yaca-test-key.cpp
index 6e42f69..6919a1c 100644 (file)
--- a/src/yaca/yaca-test-key.cpp
+++ b/src/yaca/yaca-test-key.cpp
@@ -60,6 +60,33 @@ void key_gen_invalid_param(yaca_key_type_e key_type,
                     "Non-empty key returned from a function that failed");
 }
 
+void key_gen_from_params_invalid_param(yaca_key_h params,
+                                       yaca_key_h *key)
+{
+    YACA_INVALID_PARAM(yaca_key_generate_from_parameters(params, key));
+
+    YACA_ASSERT_MSG(key == nullptr || *key == YACA_KEY_NULL,
+                    "Non-empty key returned from a function that failed");
+}
+
+void key_extract_public_invalid_param(yaca_key_h key,
+                                      yaca_key_h *pub)
+{
+    YACA_INVALID_PARAM(yaca_key_extract_public(key, pub));
+
+    YACA_ASSERT_MSG(pub == nullptr || *pub == YACA_KEY_NULL,
+                    "Non-empty key returned from a function that failed");
+}
+
+void key_extract_params_invalid_param(yaca_key_h key,
+                                      yaca_key_h *params)
+{
+    YACA_INVALID_PARAM(yaca_key_extract_parameters(key, params));
+
+    YACA_ASSERT_MSG(params == nullptr || *params == YACA_KEY_NULL,
+                    "Non-empty key returned from a function that failed");
+}
+
 void import_key_wrong_password(yaca_key_type_e key_type,
                                const std::string &password,
                                const char *data,
@@ -149,81 +176,156 @@ RUNNER_TEST(T4009_yaca_key_derive_pbkdf2)
 {
 }
 
-RUNNER_TEST(T4010_yaca_key_generate_wrong_type, YacaTest)
+RUNNER_TEST(T4010_yaca_key_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
 
-    key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &key);
+    key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &out);
+    key_gen_from_params_invalid_param(nullptr, &out);
+    key_extract_public_invalid_param(nullptr, &out);
+    key_extract_params_invalid_param(nullptr, &out);
 }
 
-RUNNER_TEST(T4020_yaca_key_generate_symmetric_invalid_param, YacaTest)
+RUNNER_TEST(T4020_yaca_key_symmetric_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
 
     key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &key);
+    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 0, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_SYMMETRIC, 69, &out);
 }
 
-RUNNER_TEST(T4030_yaca_key_generate_iv_invalid_param, YacaTest)
+RUNNER_TEST(T4030_yaca_key_iv_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
 
     key_gen_invalid_param(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_256BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &key);
+    key_gen_invalid_param(YACA_KEY_TYPE_IV, 0, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_IV, 1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_IV, 69, &out);
 }
 
-RUNNER_TEST(T4040_yaca_key_generate_des_invalid_param, YacaTest)
+RUNNER_TEST(T4040_yaca_key_des_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
 
     key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &key);
+    key_gen_invalid_param(YACA_KEY_TYPE_DES, 0, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DES, 1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DES, 69, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DES, 72, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_256BIT, &out);
 }
 
-RUNNER_TEST(T4050_yaca_key_generate_rsa_invalid_param, YacaTest)
+RUNNER_TEST(T4050_yaca_key_rsa_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
+    KeyPtr priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    KeyPtr pub = extract_public_key(priv);
 
+    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
     key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &key);
+    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, 1023, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+
+    key_gen_from_params_invalid_param(priv.get(), &out);
+    key_gen_from_params_invalid_param(pub.get(), &out);
+
+    key_extract_public_invalid_param(priv.get(), nullptr);
+    key_extract_public_invalid_param(pub.get(), &out);
+
+    key_extract_params_invalid_param(priv.get(), &out);
+    key_extract_params_invalid_param(pub.get(), &out);
 }
 
-RUNNER_TEST(T4060_yaca_key_generate_dsa_invalid_param, YacaTest)
+RUNNER_TEST(T4060_yaca_key_dsa_invalid_param, YacaTest)
 {
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
+    KeyPtr priv = generate_key(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    KeyPtr pub = extract_public_key(priv);
+    KeyPtr params = extract_parameters(priv);
 
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &out);
     key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PUB, YACA_KEY_LENGTH_1024BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT , &key);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_1024BIT, nullptr);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_UNSAFE_128BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1016, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1016, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, 1023, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, 1023, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_256BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_256BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DSA_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+
+    key_gen_from_params_invalid_param(params.get(), nullptr);
+    key_gen_from_params_invalid_param(priv.get(), &out);
+    key_gen_from_params_invalid_param(pub.get(), &out);
+
+    key_extract_public_invalid_param(priv.get(), nullptr);
+    key_extract_public_invalid_param(pub.get(), &out);
+
+    key_extract_params_invalid_param(priv.get(), nullptr);
+    key_extract_params_invalid_param(params.get(), &out);
 }
 
-// ECDSA not yet implemented
-#if 0
-RUNNER_TEST(T4070_yaca_key_generate_ecdsa_invalid_param, YacaTest)
+RUNNER_TEST(T4065_yaca_key_dh_invalid_param, YacaTest)
 {
-    RUNNER_IGNORED_MSG("ECDSA is not supported yet");
-    yaca_key_h key = YACA_KEY_NULL;
+    yaca_key_h out = YACA_KEY_NULL;
+    KeyPtr priv = generate_key(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256);
+    KeyPtr pub = extract_public_key(priv);
+    KeyPtr params = extract_parameters(priv);
+
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PUB, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, nullptr);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_512BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_DH_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+
+    key_gen_from_params_invalid_param(params.get(), nullptr);
+    key_gen_from_params_invalid_param(priv.get(), &out);
+    key_gen_from_params_invalid_param(pub.get(), &out);
+
+    key_extract_public_invalid_param(priv.get(), nullptr);
+    key_extract_public_invalid_param(pub.get(), &out);
+
+    key_extract_params_invalid_param(priv.get(), nullptr);
+    key_extract_params_invalid_param(params.get(), &out);
+}
 
-    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_256BIT, nullptr);
-    key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_CURVE_P192, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_UNSAFE_128BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &key);
-    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, 193, &key);
+RUNNER_TEST(T4070_yaca_key_ec_invalid_param, YacaTest)
+{
+    yaca_key_h out = YACA_KEY_NULL;
+    KeyPtr priv = generate_key(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1);
+    KeyPtr pub = extract_public_key(priv);
+    KeyPtr params = extract_parameters(priv);
+
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PUB, YACA_KEY_LENGTH_EC_PRIME256V1, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_EC_PRIME256V1, nullptr);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_512BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_512BIT, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+    key_gen_invalid_param(YACA_KEY_TYPE_EC_PARAMS, YACA_KEY_LENGTH_DH_RFC_2048_256, &out);
+
+    key_gen_from_params_invalid_param(params.get(), nullptr);
+    key_gen_from_params_invalid_param(priv.get(), &out);
+    key_gen_from_params_invalid_param(pub.get(), &out);
+
+    key_extract_public_invalid_param(priv.get(), nullptr);
+    key_extract_public_invalid_param(pub.get(), &out);
+
+    key_extract_params_invalid_param(priv.get(), nullptr);
+    key_extract_params_invalid_param(params.get(), &out);
 }
-#endif
 
 RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
 {