YACA: Add seal/open invalid param tests.

Change-Id: I4fdfb2794349c3b9a9c404b8452338be949c7870

diff --git a/src/yaca/yaca-test-common.cpp b/src/yaca/yaca-test-common.cpp
index e76af89..e321115 100644 (file)
--- a/src/yaca/yaca-test-common.cpp
+++ b/src/yaca/yaca-test-common.cpp
@@ -250,6 +250,21 @@ CtxPtr seal_init(const KeyPtr &key_pub,
     return wrap_ptr(ctx);
 }
 
+CtxPtr open_init(const KeyPtr &key_priv,
+                 yaca_encrypt_algorithm_e algo,
+                 yaca_block_cipher_mode_e bcm,
+                 size_t sym_key_bit_len,
+                 const KeyPtr& sym_key,
+                 const KeyPtr& iv)
+{
+    yaca_context_h ctx = YACA_CONTEXT_NULL;
+
+    YACA_SUCCESS(yaca_open_initialize(&ctx, key_priv.get(), algo, bcm, sym_key_bit_len,
+                                      sym_key.get(), iv.get()));
+
+    return wrap_ptr(ctx);
+}
+
 CtxPtr sign_init(yaca_digest_algorithm_e algo, const KeyPtr &key_prv)
 {
     yaca_context_h ctx = YACA_CONTEXT_NULL;
@@ -312,6 +327,12 @@ Buffer random_buffer(size_t length)
     return buffer;
 }
 
+ChrPtr out_buf_alloc(const CtxPtr& ctx_ptr, size_t input_len, size_t &out_len)
+{
+    out_len = get_output_length(ctx_ptr, input_len);
+    return create_yaca_buffer(out_len);
+}
+
 #define ENUM_DESCRIBE(enum_value) case (enum_value): return #enum_value;
 const char* keytype2str(yaca_key_type_e key_type)
 {

diff --git a/src/yaca/yaca-test-common.h b/src/yaca/yaca-test-common.h
index 8a3a120..3fe2629 100644 (file)
--- a/src/yaca/yaca-test-common.h
+++ b/src/yaca/yaca-test-common.h
@@ -175,6 +175,13 @@ CtxPtr seal_init(const KeyPtr &key_pub,
                  KeyPtr &sym_key_ptr,
                  KeyPtr &iv_ptr);
 
+CtxPtr open_init(const KeyPtr &key_priv,
+                 yaca_encrypt_algorithm_e algo,
+                 yaca_block_cipher_mode_e bcm,
+                 size_t sym_key_bit_len,
+                 const KeyPtr& sym_key,
+                 const KeyPtr& iv);
+
 CtxPtr encrypt_init(yaca_encrypt_algorithm_e algo,
                     yaca_block_cipher_mode_e bcm,
                     const KeyPtr &sym_key,
@@ -197,6 +204,8 @@ CtxPtr digest_init(yaca_digest_algorithm_e algo);
 
 Buffer random_buffer(size_t length);
 
+ChrPtr out_buf_alloc(const CtxPtr& ctx_ptr, size_t input_len, size_t &out_len);
+
 const char* keytype2str(yaca_key_type_e algo);
 
 const char* digest2str(yaca_digest_algorithm_e algo);

diff --git a/src/yaca/yaca-test-encrypt.cpp b/src/yaca/yaca-test-encrypt.cpp
index 7da051c..298a892 100644 (file)
--- a/src/yaca/yaca-test-encrypt.cpp
+++ b/src/yaca/yaca-test-encrypt.cpp
@@ -44,12 +44,6 @@ public:
                   {}
 };
 
-ChrPtr out_buf_alloc(const CtxPtr& ctx_ptr, size_t input_len, size_t &out_len)
-{
-    out_len = get_output_length(ctx_ptr, input_len);
-    return create_yaca_buffer(out_len);
-}
-
 yaca_key_type_e algo_to_key_type(yaca_encrypt_algorithm_e algo)
 {
     if (algo == YACA_ENCRYPT_3DES_3TDEA ||

diff --git a/src/yaca/yaca-test-seal.cpp b/src/yaca/yaca-test-seal.cpp
index 6b4fca9..dc259f6 100644 (file)
--- a/src/yaca/yaca-test-seal.cpp
+++ b/src/yaca/yaca-test-seal.cpp
@@ -22,32 +22,240 @@
  */
 
 #include "dpl/test/test_runner.h"
+#include "yaca-test-common.h"
+#include "yaca-test-vector.h"
 
 #include <yaca_seal.h>
+#include <yaca_encrypt.h>
+#include <yaca_key.h>
 
+const Buffer DATA = random_buffer(1024);
 
 RUNNER_TEST_GROUP_INIT(T5000_YACA_SEAL);
 
-RUNNER_TEST(T5001_yaca_seal_init)
+RUNNER_TEST(T5010_yaca_seal_init_invalid_param, YacaTest)
 {
+    yaca_context_h ctx;
+    yaca_key_h sym_key;
+    yaca_key_h iv;
+
+    yaca_encrypt_algorithm_e algo = YACA_ENCRYPT_AES;
+    yaca_block_cipher_mode_e bcm = YACA_BCM_CBC;
+    size_t sym_key_bit_len = YACA_KEY_LENGTH_192BIT;
+
+    auto rsa_priv_key_ptr = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub_key_ptr = extract_public_key(rsa_priv_key_ptr);
+
+    auto dsa_priv_key_ptr = generate_key(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto dsa_pub_key_ptr = extract_public_key(dsa_priv_key_ptr);
+    auto dsa_params_ptr = extract_parameters(dsa_priv_key_ptr);
+
+    auto aes_key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(nullptr, rsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, YACA_KEY_NULL, algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, dsa_priv_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, dsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, dsa_params_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, aes_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, &iv));
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(),
+                                            static_cast<yaca_encrypt_algorithm_e>(-1),
+                                            bcm, sym_key_bit_len, &sym_key, &iv));
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo,
+                                            static_cast<yaca_block_cipher_mode_e>(-1),
+                                            sym_key_bit_len, &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, YACA_BCM_WRAP, sym_key_bit_len,
+                                            &sym_key, &iv));
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, 512, &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, 64, &sym_key, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, 63, &sym_key, &iv));
+
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            nullptr, &iv));
+    YACA_INVALID_PARAM(yaca_seal_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            &sym_key, nullptr));
 }
 
-RUNNER_TEST(T5002_yaca_seal_update)
+RUNNER_TEST(T5020_yaca_seal_update_invalid_param, YacaTest)
 {
+    size_t ciphertext_len = 0;
+    KeyPtr sym_key = null_key();
+    KeyPtr iv = null_key();
+
+    auto rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub = extract_public_key(rsa_priv);
+
+    auto seal_ctx_ptr = seal_init(rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+    auto open_ctx_ptr = open_init(rsa_priv, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+
+    auto ciphertext_ptr = out_buf_alloc(seal_ctx_ptr, DATA.size(), ciphertext_len);
+
+    YACA_INVALID_PARAM(yaca_seal_update(YACA_CONTEXT_NULL, DATA.data(), DATA.size(),
+                                        ciphertext_ptr.get(), &ciphertext_len));
+    YACA_INVALID_PARAM(yaca_seal_update(open_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        ciphertext_ptr.get(), &ciphertext_len));
+
+    YACA_INVALID_PARAM(yaca_seal_update(seal_ctx_ptr.get(), nullptr, DATA.size(),
+                                        ciphertext_ptr.get(), &ciphertext_len));
+
+    YACA_INVALID_PARAM(yaca_seal_update(seal_ctx_ptr.get(), DATA.data(), 0,
+                                        ciphertext_ptr.get(), &ciphertext_len));
+
+    YACA_INVALID_PARAM(yaca_seal_update(seal_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        nullptr, &ciphertext_len));
+
+    YACA_INVALID_PARAM(yaca_seal_update(seal_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        ciphertext_ptr.get(), nullptr));
 }
 
-RUNNER_TEST(T5003_yaca_seal_final)
+RUNNER_TEST(T5030_yaca_seal_final_invalid_param, YacaTest)
 {
+    size_t ciphertext_len = 0;
+    KeyPtr sym_key = null_key();
+    KeyPtr iv = null_key();
+
+    auto rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub = extract_public_key(rsa_priv);
+
+    auto seal_ctx_ptr = seal_init(rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+    auto open_ctx_ptr = open_init(rsa_priv, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+
+    auto ciphertext_ptr = out_buf_alloc(seal_ctx_ptr, DATA.size(), ciphertext_len);
+
+    YACA_INVALID_PARAM(yaca_seal_finalize(YACA_CONTEXT_NULL, ciphertext_ptr.get(), &ciphertext_len));
+    YACA_INVALID_PARAM(yaca_seal_finalize(open_ctx_ptr.get(), ciphertext_ptr.get(), &ciphertext_len));
+    YACA_INVALID_PARAM(yaca_seal_finalize(seal_ctx_ptr.get(), nullptr, &ciphertext_len));
+    YACA_INVALID_PARAM(yaca_seal_finalize(seal_ctx_ptr.get(), ciphertext_ptr.get(), nullptr));
 }
 
-RUNNER_TEST(T5004_yaca_open_init)
+RUNNER_TEST(T5040_yaca_open_init_invalid_param, YacaTest)
 {
+    yaca_context_h ctx;
+    KeyPtr sym_key = null_key();
+    KeyPtr iv = null_key();
+
+    yaca_encrypt_algorithm_e algo = YACA_ENCRYPT_AES;
+    yaca_block_cipher_mode_e bcm = YACA_BCM_CBC;
+    size_t sym_key_bit_len = YACA_KEY_LENGTH_192BIT;
+
+    auto rsa_priv_key_ptr = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub_key_ptr = extract_public_key(rsa_priv_key_ptr);
+
+    auto seal_ctx_ptr = seal_init(rsa_pub_key_ptr, algo, bcm, sym_key_bit_len, sym_key, iv);
+
+    auto dsa_priv_key_ptr = generate_key(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto dsa_pub_key_ptr = extract_public_key(dsa_priv_key_ptr);
+    auto dsa_params_ptr = extract_parameters(dsa_priv_key_ptr);
+
+    auto aes_key_ptr = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+
+    YACA_INVALID_PARAM(yaca_open_initialize(nullptr, rsa_priv_key_ptr.get(), algo, bcm,
+                                            sym_key_bit_len, sym_key.get(), iv.get()));
+
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, YACA_KEY_NULL, algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, dsa_priv_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, dsa_pub_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, dsa_params_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, aes_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), iv.get()));
+
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(),
+                                            static_cast<yaca_encrypt_algorithm_e>(-1),
+                                            bcm, sym_key_bit_len, sym_key.get(), iv.get()));
+
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo,
+                                            static_cast<yaca_block_cipher_mode_e>(-1),
+                                            sym_key_bit_len, sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, YACA_BCM_WRAP,
+                                            sym_key_bit_len, sym_key.get(), iv.get()));
+
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, 512,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, 64,
+                                            sym_key.get(), iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, 63,
+                                            sym_key.get(), iv.get()));
+
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            YACA_KEY_NULL, iv.get()));
+    YACA_INVALID_PARAM(yaca_open_initialize(&ctx, rsa_priv_key_ptr.get(), algo, bcm, sym_key_bit_len,
+                                            sym_key.get(), YACA_KEY_NULL));
 }
 
-RUNNER_TEST(T5005_yaca_open_update)
+RUNNER_TEST(T5050_yaca_open_update_invalid_param, YacaTest)
 {
+    size_t plaintext_len = 0;
+    KeyPtr sym_key = null_key();
+    KeyPtr iv = null_key();
+
+    auto rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub = extract_public_key(rsa_priv);
+
+    auto seal_ctx_ptr = seal_init(rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+    auto open_ctx_ptr = open_init(rsa_priv, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+
+    auto plaintext_ptr = out_buf_alloc(open_ctx_ptr, DATA.size(), plaintext_len);
+
+    YACA_INVALID_PARAM(yaca_open_update(YACA_CONTEXT_NULL, DATA.data(), DATA.size(),
+                                        plaintext_ptr.get(), &plaintext_len));
+    YACA_INVALID_PARAM(yaca_open_update(seal_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        plaintext_ptr.get(), &plaintext_len));
+
+    YACA_INVALID_PARAM(yaca_open_update(open_ctx_ptr.get(), nullptr, DATA.size(),
+                                        plaintext_ptr.get(), &plaintext_len));
+
+    YACA_INVALID_PARAM(yaca_open_update(open_ctx_ptr.get(), DATA.data(), 0,
+                                        plaintext_ptr.get(), &plaintext_len));
+
+    YACA_INVALID_PARAM(yaca_open_update(open_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        nullptr, &plaintext_len));
+
+    YACA_INVALID_PARAM(yaca_open_update(open_ctx_ptr.get(), DATA.data(), DATA.size(),
+                                        plaintext_ptr.get(), nullptr));
 }
 
-RUNNER_TEST(T5006_yaca_open_final)
+RUNNER_TEST(T5060_yaca_open_final_invalid_param, YacaTest)
 {
+    size_t plaintext_len = 0;
+    KeyPtr sym_key = null_key();
+    KeyPtr iv = null_key();
+
+    auto rsa_priv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    auto rsa_pub = extract_public_key(rsa_priv);
+
+    auto seal_ctx_ptr = seal_init(rsa_pub, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+    auto open_ctx_ptr = open_init(rsa_priv, YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                  sym_key, iv);
+
+    auto plaintext_ptr = out_buf_alloc(open_ctx_ptr, DATA.size(), plaintext_len);
+
+    YACA_INVALID_PARAM(yaca_open_finalize(YACA_CONTEXT_NULL, plaintext_ptr.get(), &plaintext_len));
+    YACA_INVALID_PARAM(yaca_open_finalize(seal_ctx_ptr.get(), plaintext_ptr.get(), &plaintext_len));
+    YACA_INVALID_PARAM(yaca_open_finalize(open_ctx_ptr.get(), nullptr, &plaintext_len));
+    YACA_INVALID_PARAM(yaca_open_finalize(open_ctx_ptr.get(), plaintext_ptr.get(), nullptr));
 }