projects / platform / core / test / security-tests.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: dac31b9)
YACA: invalid param tests for simple sign/verify/hmac/cmac 64/77364/2
authorLukasz Pawelczyk <l.pawelczyk@samsung.com>
Wed, 29 Jun 2016 11:45:55 +0000 (13:45 +0200)
committerLukasz Pawelczyk <l.pawelczyk@samsung.com>
Wed, 29 Jun 2016 12:46:09 +0000 (14:46 +0200)
Change-Id: I56f80163daac1126a9031ea7258473b0c54073f8

src/yaca/yaca-test-simple.cpp patch | blob | history

diff --git a/src/yaca/yaca-test-simple.cpp b/src/yaca/yaca-test-simple.cpp
index 83d6b73..138208b 100644 (file)
--- a/src/yaca/yaca-test-simple.cpp
+++ b/src/yaca/yaca-test-simple.cpp
@@ -31,15 +31,15 @@ namespace {
 
 void check_test_vector(yaca_digest_algorithm_e algo,
                        size_t repeats,
-                       const Buffer& single_input,
-                       const Buffer& expected)
+                       const Buffer &single_input,
+                       const Buffer &expected)
 {
     /* concatenate input if needed */
     Buffer input(single_input);
     for (size_t i = 1; i < repeats; i++)
         input.insert(input.end(), single_input.begin(), single_input.end());
 
-    char* digest;
+    char *digest;
     size_t digest_len;
     YACA_SUCCESS(yaca_simple_calculate_digest(algo,
                                               input.data(),
@@ -72,7 +72,7 @@ RUNNER_TEST_GROUP_INIT(T7000_YACA_SIMPLE);
 
 RUNNER_TEST(T7010_yaca_simple_calculate_digest_invalid_param, YacaTest)
 {
-    char* digest;
+    char *digest;
     size_t digest_len;
     Buffer data = random_buffer(42);
 
@@ -107,7 +107,7 @@ RUNNER_TEST(T7020_yaca_simple_calculate_digest_ascii_vectors, YacaTest)
 {
     auto tvv = loadTestVector("digest_ascii.txt");
 
-    for (const auto& tv : tvv) {
+    for (const auto &tv : tvv) {
         yaca_digest_algorithm_e algo;
         size_t repeats;
         std::string input;
@@ -126,7 +126,7 @@ RUNNER_TEST(T7030_yaca_simple_calculate_digest_binary_vectors, YacaTest)
 {
     auto tvv = loadTestVector("digest_binary.txt");
 
-    for (const auto& tv : tvv) {
+    for (const auto &tv : tvv) {
         yaca_digest_algorithm_e algo;
         size_t repeats;
         Buffer input;
@@ -141,10 +141,238 @@ RUNNER_TEST(T7030_yaca_simple_calculate_digest_binary_vectors, YacaTest)
     }
 }
 
-RUNNER_TEST(T7002_yaca_encrypt)
+RUNNER_TEST(T7040_yaca_simple_calculate_signature_invalid_param, YacaTest)
 {
+    char *signature;
+    size_t signature_len;
+    Buffer data = random_buffer(42);
+    KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPtr key_pub = extract_public_key(key_prv);
+    KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
+
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(static_cast<yaca_digest_algorithm_e>(-1),
+                                                       key_prv.get(),
+                                                       data.data(),
+                                                       data.size(),
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       nullptr,
+                                                       data.data(),
+                                                       data.size(),
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_pub.get(),
+                                                       data.data(),
+                                                       data.size(),
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_sym.get(),
+                                                       data.data(),
+                                                       data.size(),
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_prv.get(),
+                                                       nullptr,
+                                                       data.size(),
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_prv.get(),
+                                                       data.data(),
+                                                       0,
+                                                       &signature,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_prv.get(),
+                                                       data.data(),
+                                                       data.size(),
+                                                       nullptr,
+                                                       &signature_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_signature(YACA_DIGEST_MD5,
+                                                       key_prv.get(),
+                                                       data.data(),
+                                                       data.size(),
+                                                       &signature,
+                                                       nullptr));
+}
+
+RUNNER_TEST(T7050_yaca_simple_verify_signature_invalid_param, YacaTest)
+{
+    size_t signature_len;
+    Buffer data = random_buffer(42);
+    KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPtr key_pub = extract_public_key(key_prv);
+    KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
+    ChrPtr signature = simple_sign(YACA_DIGEST_MD5, key_prv, data.data(), data.size(), &signature_len);
+
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(static_cast<yaca_digest_algorithm_e>(-1),
+                                                    key_pub.get(),
+                                                    data.data(),
+                                                    data.size(),
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    nullptr,
+                                                    data.data(),
+                                                    data.size(),
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_prv.get(),
+                                                    data.data(),
+                                                    data.size(),
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_sym.get(),
+                                                    data.data(),
+                                                    data.size(),
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_pub.get(),
+                                                    nullptr,
+                                                    data.size(),
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_pub.get(),
+                                                    data.data(),
+                                                    0,
+                                                    signature.get(),
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_pub.get(),
+                                                    data.data(),
+                                                    data.size(),
+                                                    nullptr,
+                                                    signature_len));
+    YACA_INVALID_PARAM(yaca_simple_verify_signature(YACA_DIGEST_MD5,
+                                                    key_pub.get(),
+                                                    data.data(),
+                                                    data.size(),
+                                                    signature.get(),
+                                                    0));
+}
+
+RUNNER_TEST(T7060_yaca_simple_calculate_hmac_invalid_param, YacaTest)
+{
+    char *mac;
+    size_t mac_len;
+    Buffer data = random_buffer(42);
+    KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
+    KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPtr key_pub = extract_public_key(key_prv);
+
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(static_cast<yaca_digest_algorithm_e>(-1),
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  nullptr,
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_prv.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_pub.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_sym.get(),
+                                                  nullptr,
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  0,
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  nullptr,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_hmac(YACA_DIGEST_MD5,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  nullptr));
 }
 
-RUNNER_TEST(T7003_yaca_decrypt)
+RUNNER_TEST(T7070_yaca_simple_calculate_cmac_invalid_param, YacaTest)
 {
+    char *mac;
+    size_t mac_len;
+    Buffer data = random_buffer(42);
+    KeyPtr key_sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, 256);
+    KeyPtr key_prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPtr key_pub = extract_public_key(key_prv);
+
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(static_cast<yaca_encrypt_algorithm_e>(-1),
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  nullptr,
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_prv.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_pub.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_sym.get(),
+                                                  nullptr,
+                                                  data.size(),
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  0,
+                                                  &mac,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  nullptr,
+                                                  &mac_len));
+    YACA_INVALID_PARAM(yaca_simple_calculate_cmac(YACA_ENCRYPT_AES,
+                                                  key_sym.get(),
+                                                  data.data(),
+                                                  data.size(),
+                                                  &mac,
+                                                  nullptr));
 }
Domain: Security / Uncategorized;