YACA: Key generation and getter tests

Change-Id: I78d7aa7bbaef81fa49a9900d7b18026673079909

diff --git a/src/yaca/yaca-test-key.cpp b/src/yaca/yaca-test-key.cpp
index 6d273ed..76baf46 100644 (file)
--- a/src/yaca/yaca-test-key.cpp
+++ b/src/yaca/yaca-test-key.cpp
@@ -23,28 +23,51 @@
 
 #include "dpl/test/test_runner.h"
 
+#include <stdint.h>
+
 #include <yaca_key.h>
+#include <yaca_error.h>
 
+#include "yaca-test-common.h"
 
-RUNNER_TEST_GROUP_INIT(T4000_YACA_KEY);
+namespace {
 
-RUNNER_TEST(T4001_yaca_key_get_bits)
+void key_gen_test(yaca_key_type_e expected_type, size_t expected_bits)
 {
-}
+    size_t bits;
+    yaca_key_type_e type;
 
-RUNNER_TEST(T4002_yaca_key_import)
-{
+    auto key_ptr = generate_key(expected_type, expected_bits);
+
+    YACA_SUCCESS(yaca_key_get_bit_length(key_ptr.get(), &bits));
+    YACA_ASSERT_MSG(bits == expected_bits,
+                    "Expected key length: " << expected_bits << " got: " << bits);
+
+    YACA_SUCCESS(yaca_key_get_type(key_ptr.get(), &type));
+    YACA_ASSERT_MSG(type == expected_type,
+                    "Expected key type: " << expected_type << " got: " << bits);
 }
 
-RUNNER_TEST(T4003_yaca_key_export)
+void key_gen_invalid_param(yaca_key_type_e key_type,
+                           size_t key_bit_len,
+                           yaca_key_h *key)
 {
+    YACA_INVALID_PARAM(yaca_key_generate(key_type, key_bit_len, key));
+
+    YACA_ASSERT_MSG(key == NULL || *key == YACA_KEY_NULL,
+                    "Non-empty key returned from a function that failed");
 }
 
-RUNNER_TEST(T4004_yaca_key_gen)
+} // anonymous namespace
+
+RUNNER_TEST_GROUP_INIT(T4000_YACA_KEY);
+
+
+RUNNER_TEST(T4002_yaca_key_import)
 {
 }
 
-RUNNER_TEST(T4005_yaca_key_gen_pair)
+RUNNER_TEST(T4003_yaca_key_export)
 {
 }
 
@@ -63,3 +86,158 @@ RUNNER_TEST(T4008_yaca_key_derive_kea)
 RUNNER_TEST(T4009_yaca_key_derive_pbkdf2)
 {
 }
+
+RUNNER_TEST(T4010_yaca_key_generate_wrong_type, YacaTest)
+{
+    yaca_key_h key = YACA_KEY_NULL;
+
+    key_gen_invalid_param(static_cast<yaca_key_type_e>(-1), YACA_KEY_LENGTH_256BIT, &key);
+}
+
+RUNNER_TEST(T4020_yaca_key_generate_symmetric_invalid_param, YacaTest)
+{
+    yaca_key_h key = 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);
+}
+
+RUNNER_TEST(T4030_yaca_key_generate_iv_invalid_param, YacaTest)
+{
+    yaca_key_h key = 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);
+}
+
+RUNNER_TEST(T4040_yaca_key_generate_des_invalid_param, YacaTest)
+{
+    yaca_key_h key = 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);
+}
+
+RUNNER_TEST(T4050_yaca_key_generate_rsa_invalid_param, YacaTest)
+{
+    yaca_key_h key = YACA_KEY_NULL;
+
+    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);
+}
+
+RUNNER_TEST(T4060_yaca_key_generate_dsa_invalid_param, YacaTest)
+{
+    yaca_key_h key = YACA_KEY_NULL;
+
+    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);
+}
+
+// ECDSA not yet implemented
+#if 0
+RUNNER_TEST(T4070_yaca_key_generate_ecdsa_invalid_param, YacaTest)
+{
+    RUNNER_IGNORED_MSG("ECDSA is not supported yet");
+    yaca_key_h key = YACA_KEY_NULL;
+
+    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);
+}
+#endif
+
+RUNNER_TEST(T4080_yaca_key_generate_symmetric, YacaTest)
+{
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 72);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 1016);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_4096BIT);
+    key_gen_test(YACA_KEY_TYPE_SYMMETRIC, 8192);
+}
+
+RUNNER_TEST(T4090_yaca_key_generate_iv, YacaTest)
+{
+    key_gen_test(YACA_KEY_TYPE_IV, 8);
+    key_gen_test(YACA_KEY_TYPE_IV, 72);
+    key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_UNSAFE_24BIT);
+    key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_512BIT);
+    key_gen_test(YACA_KEY_TYPE_IV, 1016);
+    key_gen_test(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_4096BIT);
+    key_gen_test(YACA_KEY_TYPE_IV, 8192);
+}
+
+RUNNER_TEST(T4100_yaca_key_generate_des, YacaTest)
+{
+    key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_64BIT);
+    key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_UNSAFE_128BIT);
+    key_gen_test(YACA_KEY_TYPE_DES, YACA_KEY_LENGTH_192BIT);
+}
+
+RUNNER_TEST(T4110_yaca_key_generate_rsa, YacaTest)
+{
+    key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_256BIT);
+    key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    key_gen_test(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_2048BIT);
+    key_gen_test(YACA_KEY_TYPE_RSA_PRIV, 1016);
+}
+
+RUNNER_TEST(T4120_yaca_key_generate_dsa, YacaTest)
+{
+    key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    key_gen_test(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_2048BIT);
+    key_gen_test(YACA_KEY_TYPE_DSA_PRIV, 1088);
+}
+
+// ECDSA not yet implemented
+#if 0
+RUNNER_TEST(T4130_yaca_key_generate_ecdsa, YacaTest)
+{
+    RUNNER_IGNORED_MSG("ECDSA is not supported yet");
+    key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P192);
+    key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P256);
+    key_gen_test(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_CURVE_P384);
+}
+#endif
+
+RUNNER_TEST(T4200_yaca_key_get_type_invalid_param, YacaTest)
+{
+    yaca_key_type_e type;
+
+    YACA_INVALID_PARAM(yaca_key_get_type(YACA_KEY_NULL, &type));
+
+    auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
+
+    YACA_INVALID_PARAM(yaca_key_get_type(key_ptr.get(), nullptr));
+}
+
+RUNNER_TEST(T4210_yaca_key_get_bits_invalid_param, YacaTest)
+{
+    size_t bits;
+
+    YACA_INVALID_PARAM(yaca_key_get_bit_length(YACA_KEY_NULL, &bits));
+
+    auto key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_512BIT);
+
+    YACA_INVALID_PARAM(yaca_key_get_bit_length(key_ptr.get(), nullptr));
+}