Merge branch 'tizen' into yaca

Change-Id: I66c4ba82d00193ad53841d36d8559fa438771305

diff --git a/src/yaca/test-vectors/sign_param_comb.txt b/src/yaca/test-vectors/sign_param_comb.txt
new file mode 100644 (file)
index 0000000..3dda1bb
--- /dev/null
+++ b/src/yaca/test-vectors/sign_param_comb.txt
@@ -0,0 +1,415 @@
+# YACA_KEY_LENGTH_EC_PRIME192V1 - 805306560
+# YACA_KEY_LENGTH_EC_PRIME256V1 - 805306624
+# YACA_KEY_LENGTH_EC_SECP256K1  - 824180992
+# YACA_KEY_LENGTH_EC_SECP384R1  - 823132544
+# YACA_KEY_LENGTH_EC_SECP521R1  - 823132681
+
+key_type=EC_PRIV
+key_len_bits=805306560
+padding=
+algo=SHA1
+
+key_type=EC_PRIV
+key_len_bits=805306560
+padding=
+algo=SHA224
+
+key_type=EC_PRIV
+key_len_bits=805306560
+padding=
+algo=SHA256
+
+key_type=EC_PRIV
+key_len_bits=805306560
+padding=
+algo=SHA384
+
+key_type=EC_PRIV
+key_len_bits=805306560
+padding=
+algo=SHA512
+
+key_type=EC_PRIV
+key_len_bits=805306624
+padding=
+algo=SHA1
+
+key_type=EC_PRIV
+key_len_bits=805306624
+padding=
+algo=SHA224
+
+key_type=EC_PRIV
+key_len_bits=805306624
+padding=
+algo=SHA256
+
+key_type=EC_PRIV
+key_len_bits=805306624
+padding=
+algo=SHA384
+
+key_type=EC_PRIV
+key_len_bits=805306624
+padding=
+algo=SHA512
+
+key_type=EC_PRIV
+key_len_bits=824180992
+padding=
+algo=SHA1
+
+key_type=EC_PRIV
+key_len_bits=824180992
+padding=
+algo=SHA224
+
+key_type=EC_PRIV
+key_len_bits=824180992
+padding=
+algo=SHA256
+
+key_type=EC_PRIV
+key_len_bits=824180992
+padding=
+algo=SHA384
+
+key_type=EC_PRIV
+key_len_bits=824180992
+padding=
+algo=SHA512
+
+key_type=EC_PRIV
+key_len_bits=823132544
+padding=
+algo=SHA1
+
+key_type=EC_PRIV
+key_len_bits=823132544
+padding=
+algo=SHA224
+
+key_type=EC_PRIV
+key_len_bits=823132544
+padding=
+algo=SHA256
+
+key_type=EC_PRIV
+key_len_bits=823132544
+padding=
+algo=SHA384
+
+key_type=EC_PRIV
+key_len_bits=823132544
+padding=
+algo=SHA512
+
+key_type=EC_PRIV
+key_len_bits=823132681
+padding=
+algo=SHA1
+
+key_type=EC_PRIV
+key_len_bits=823132681
+padding=
+algo=SHA224
+
+key_type=EC_PRIV
+key_len_bits=823132681
+padding=
+algo=SHA256
+
+key_type=EC_PRIV
+key_len_bits=823132681
+padding=
+algo=SHA384
+
+key_type=EC_PRIV
+key_len_bits=823132681
+padding=
+algo=SHA512
+
+key_type=DSA_PRIV
+key_len_bits=512
+padding=
+algo=SHA1
+
+key_type=DSA_PRIV
+key_len_bits=512
+padding=
+algo=SHA224
+
+key_type=DSA_PRIV
+key_len_bits=512
+padding=
+algo=SHA256
+
+key_type=DSA_PRIV
+key_len_bits=512
+padding=
+algo=SHA384
+
+key_type=DSA_PRIV
+key_len_bits=512
+padding=
+algo=SHA512
+
+key_type=DSA_PRIV
+key_len_bits=1024
+padding=
+algo=SHA1
+
+key_type=DSA_PRIV
+key_len_bits=1024
+padding=
+algo=SHA224
+
+key_type=DSA_PRIV
+key_len_bits=1024
+padding=
+algo=SHA256
+
+key_type=DSA_PRIV
+key_len_bits=1024
+padding=
+algo=SHA384
+
+key_type=DSA_PRIV
+key_len_bits=1024
+padding=
+algo=SHA512
+
+key_type=DSA_PRIV
+key_len_bits=2048
+padding=
+algo=SHA1
+
+key_type=DSA_PRIV
+key_len_bits=2048
+padding=
+algo=SHA224
+
+key_type=DSA_PRIV
+key_len_bits=2048
+padding=
+algo=SHA256
+
+key_type=DSA_PRIV
+key_len_bits=2048
+padding=
+algo=SHA384
+
+key_type=DSA_PRIV
+key_len_bits=2048
+padding=
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1_PSS
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1_PSS
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1_PSS
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=PKCS1_PSS
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=X931
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=512
+padding=X931
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=PKCS1_PSS
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=X931
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=X931
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=X931
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=1024
+padding=X931
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=MD5
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=SHA224
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=PKCS1_PSS
+algo=SHA512
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=X931
+algo=SHA1
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=X931
+algo=SHA256
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=X931
+algo=SHA384
+
+key_type=RSA_PRIV
+key_len_bits=2048
+padding=X931
+algo=SHA512

diff --git a/src/yaca/yaca-test-digest.cpp b/src/yaca/yaca-test-digest.cpp
index 0e28fc0..f472dd6 100644 (file)
--- a/src/yaca/yaca-test-digest.cpp
+++ b/src/yaca/yaca-test-digest.cpp
@@ -149,6 +149,18 @@ RUNNER_TEST(T2040_yaca_digest_get_output_length_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_get_output_length(ctx_ptr.get(), 42, &out_len));
 }
 
+RUNNER_TEST(T2045_yaca_digest_call_order_invalid_param)
+{
+    char output[512];
+    size_t out_len;
+    CtxPtr ctx = digest_init(YACA_DIGEST_SHA512);
+
+    YACA_SUCCESS(yaca_digest_update(ctx.get(), DATA.data(), DATA.size()));
+    YACA_SUCCESS(yaca_digest_finalize(ctx.get(), output, &out_len));
+
+    YACA_INVALID_PARAM(yaca_digest_update(ctx.get(), DATA.data(), DATA.size()));
+}
+
 RUNNER_TEST(T2050_yaca_digest_get_output_length, YacaTest)
 {
     digest_length_test(YACA_DIGEST_MD5,    128);

diff --git a/src/yaca/yaca-test-encrypt.cpp b/src/yaca/yaca-test-encrypt.cpp
index d27cc5e..9ab048f 100644 (file)
--- a/src/yaca/yaca-test-encrypt.cpp
+++ b/src/yaca/yaca-test-encrypt.cpp
@@ -90,17 +90,17 @@ public:
     void set_padding(yaca_padding_e padding)
     {
         YACA_SUCCESS(yaca_context_set_property(m_enCtxPtr.get(), YACA_PROPERTY_PADDING,
-                                               (char*)(&padding), sizeof(padding)));
+                                               (void*)(&padding), sizeof(padding)));
         YACA_SUCCESS(yaca_context_set_property(m_decCtxPtr.get(), YACA_PROPERTY_PADDING,
-                                               (char*)(&padding), sizeof(padding)));
+                                               (void*)(&padding), sizeof(padding)));
     }
 
     void set_effective_key_bits(size_t key_bits)
     {
         YACA_SUCCESS(yaca_context_set_property(m_enCtxPtr.get(), YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
-                                               (char*)(&key_bits), sizeof(key_bits)));
+                                               (void*)(&key_bits), sizeof(key_bits)));
         YACA_SUCCESS(yaca_context_set_property(m_decCtxPtr.get(), YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
-                                               (char*)(&key_bits), sizeof(key_bits)));
+                                               (void*)(&key_bits), sizeof(key_bits)));
     }
 
     int set_tag_len(yaca_block_cipher_mode_e bcm, size_t tag_len)
@@ -367,7 +367,7 @@ void aes_gcm_test_output(const Buffer &input,
                                   : null_key();
 
     size_t tag_len = tag.size();
-    auto tag_output = create_yaca_buffer(tag_len);
+    char *tag_output;
 
     // encryption
     Buffer encrypt_output;
@@ -393,12 +393,13 @@ void aes_gcm_test_output(const Buffer &input,
     YACA_SUCCESS(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                            (void*)&tag_len, sizeof(tag_len)));
     YACA_SUCCESS(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                           (void**)tag_output.get(), &tag_len));
+                                           (void**)&tag_output, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag_output);
 
     YACA_ASSERT_MSG(output.size() == encrypt_output.size(), "Ciphertext size after encrypt differs\n");
     YACA_ASSERT_MSG(output == encrypt_output, "Ciphertext after encrypt differs\n");
     YACA_ASSERT_MSG(tag.size() == tag_len, "Tag size after encrypt differs\n");
-    YACA_ASSERT_MSG(yaca_memcmp(tag.data(), tag_output.get(), tag_len) == YACA_ERROR_NONE,
+    YACA_ASSERT_MSG(yaca_memcmp(tag.data(), tag_output, tag_len) == YACA_ERROR_NONE,
                     "Tag after encrypt differs\n");
 
     // decryption
@@ -440,7 +441,7 @@ void aes_ccm_test_output(const Buffer &input,
                                   : null_key();
 
     size_t tag_len = tag.size();
-    auto tag_output = create_yaca_buffer(tag_len);
+    char *tag_output;
 
     // encryption
     Buffer encrypt_output;
@@ -469,12 +470,13 @@ void aes_ccm_test_output(const Buffer &input,
     encrypt_output.insert(encrypt_output.end(), final_ptr.get(), final_ptr.get() + final_len);
 
     YACA_SUCCESS(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                           (void**)tag_output.get(), &tag_len));
+                                           (void**)&tag_output, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag_output);
 
     YACA_ASSERT_MSG(output.size() == encrypt_output.size(), "Ciphertext size after encrypt differs \n");
     YACA_ASSERT_MSG(output == encrypt_output, "ciphertext after encrypt differs\n");
     YACA_ASSERT_MSG(tag.size() == tag_len, "Tag size after encrypt differs\n");
-    YACA_ASSERT_MSG(yaca_memcmp(tag.data(), tag_output.get(), tag_len) == YACA_ERROR_NONE,
+    YACA_ASSERT_MSG(yaca_memcmp(tag.data(), tag_output, tag_len) == YACA_ERROR_NONE,
                     "Tag after encrypt differs\n");
 
     // decryption
@@ -747,6 +749,22 @@ RUNNER_TEST(T3075_yaca_key_wrap_unwrap_invalid_param, YacaTest)
                                            unwrapped.get(), &unwrapped_len));
 }
 
+RUNNER_TEST(T3077_yaca_get_iv_bit_length, YacaTest)
+{
+    size_t iv_bit_len;
+    YACA_SUCCESS(yaca_encrypt_get_iv_bit_length(YACA_ENCRYPT_AES, YACA_BCM_CBC, YACA_KEY_LENGTH_256BIT,
+                                                &iv_bit_len));
+    YACA_ASSERT_MSG(iv_bit_len == YACA_KEY_LENGTH_IV_128BIT, "Invalid IV bit length.");
+
+    YACA_SUCCESS(yaca_encrypt_get_iv_bit_length(YACA_ENCRYPT_AES, YACA_BCM_ECB, YACA_KEY_LENGTH_256BIT,
+                                                &iv_bit_len));
+    YACA_ASSERT_MSG(iv_bit_len == 0, "Invalid IV bit length.");
+
+    YACA_SUCCESS(yaca_encrypt_get_iv_bit_length(YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CBC, YACA_KEY_LENGTH_192BIT,
+                                                &iv_bit_len));
+    YACA_ASSERT_MSG(iv_bit_len == YACA_KEY_LENGTH_IV_64BIT, "Invalid IV bit length.");
+}
+
 RUNNER_TEST(T3080_yaca_encrypt_decrypt_init_param_comb, YacaTest)
 {
     auto tvv = loadTestVector("encrypt_param_comb.txt");
@@ -786,7 +804,7 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
 {
     KeyIvPair key_iv_pair;
     size_t tag_len = 14;
-    auto tag = create_yaca_buffer(tag_len);
+    char *tag;
     auto aad = random_buffer(16);
     Buffer encrypt_output;
     Buffer decrypt_output;
@@ -800,9 +818,9 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     auto final_ptr = out_buf_alloc(enc_ctx_ptr, 0, final_len);
 
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
 
@@ -816,9 +834,9 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
 
@@ -828,11 +846,13 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_SUCCESS(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                            (void*)&tag_len, sizeof(tag_len)));
     YACA_SUCCESS(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                           (void**)tag.get(), &tag_len));
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
+
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
 
@@ -843,7 +863,7 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     final_ptr = out_buf_alloc(dec_ctx_ptr, 0, final_len);
 
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
 
@@ -859,12 +879,11 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len + 42));
+                                                 tag, tag_len + 42));
 
-    YACA_SUCCESS(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                           tag.get(), tag_len));
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG, tag, tag_len));
 
     YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx_ptr.get(), final_ptr.get(), &final_len));
     decrypt_output.insert(decrypt_output.end(), final_ptr.get(), final_ptr.get() + final_len);
@@ -872,11 +891,11 @@ RUNNER_TEST(T3110_yaca_aes_gcm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_GCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
 
     YACA_ASSERT_MSG(DATA.size() == decrypt_output.size(), "Size after encrypt-decrypt differs\n");
     YACA_ASSERT_MSG(DATA == decrypt_output, "Text after encrypt-decrypt has changed\n");
@@ -887,7 +906,7 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
     KeyPtr iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_64BIT);
     size_t tag_len = 16;
-    auto tag = create_yaca_buffer(tag_len);
+    char *tag;
     auto aad = random_buffer(16);
     Buffer encrypt_output;
     Buffer decrypt_output;
@@ -900,9 +919,9 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     auto final_ptr = out_buf_alloc(enc_ctx_ptr, 0, final_len);
 
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_SUCCESS(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                            (void*)&tag_len, sizeof(tag_len)));
 
@@ -919,11 +938,11 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
 
     YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx_ptr.get(), final_ptr.get(), &final_len));
     encrypt_output.insert(encrypt_output.end(), final_ptr.get(), final_ptr.get() + final_len);
@@ -931,11 +950,12 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_SUCCESS(yaca_context_get_property(enc_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                           (void**)tag.get(), &tag_len));
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
 
     // decryption
     auto dec_ctx_ptr = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
@@ -945,19 +965,18 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len + 42));
+                                                 tag, tag_len + 42));
 
-    YACA_SUCCESS(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                           tag.get(), tag_len));
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG, tag, tag_len));
 
     YACA_SUCCESS(yaca_decrypt_update(dec_ctx_ptr.get(), NULL, encrypt_output.size(),
                                      NULL, &update_len));
     YACA_SUCCESS(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_AAD,
                                            aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
 
     YACA_SUCCESS(yaca_decrypt_update(dec_ctx_ptr.get(), encrypt_output.data(), encrypt_output.size(),
                                      update_ptr.get(), &update_len));
@@ -966,11 +985,11 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
 
     YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx_ptr.get(), final_ptr.get(), &final_len));
     decrypt_output.insert(decrypt_output.end(), final_ptr.get(), final_ptr.get() + final_len);
@@ -978,11 +997,11 @@ RUNNER_TEST(T3120_yaca_aes_ccm_call_order_invalid_param, YacaTest)
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_AAD,
                                                  aad.data(), aad.size()));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG_LEN,
                                                  (void*)&tag_len, sizeof(tag_len)));
     YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx_ptr.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (void**)&tag, &tag_len));
 
     YACA_ASSERT_MSG(DATA.size() == decrypt_output.size(), "Size after encrypt-decrypt differs\n");
     YACA_ASSERT_MSG(DATA == decrypt_output, "Text after encrypt-decrypt has changed\n");
@@ -1053,3 +1072,422 @@ RUNNER_TEST(T3150_yaca_aes_gcm_ccm_output_comparison, YacaTest)
                             : aes_ccm_test_output(input, algo, bcm, key, iv, aad, tag, output);
     }
 }
+
+RUNNER_TEST(T3160_yaca_set_get_padding_invalid_param, YacaTest)
+{
+    KeyIvPair key_iv_pair;
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CBC,
+                                  key_iv_pair.key, key_iv_pair.iv);
+
+    yaca_padding_e padding = YACA_PADDING_NONE;
+    size_t padding_len;
+
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), static_cast<yaca_property_e>(-1),
+                                                 (void*)(&padding), sizeof(padding)));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                 nullptr, sizeof(padding)));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                 (void*)(&padding), 0));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                 (void*)(&padding), sizeof(char)));
+
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                 (void**)(&padding), &padding_len));
+
+    size_t output_len = get_output_length(enc_ctx);
+    Buffer output(output_len);
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), output.data(), &output_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                 (void*)(&padding), sizeof(padding)));
+
+    std::vector<yaca_block_cipher_mode_e> bcms = {YACA_BCM_OFB, YACA_BCM_CFB, YACA_BCM_GCM,
+                                                  YACA_BCM_CTR, YACA_BCM_CBC};
+    std::vector<yaca_padding_e> paddings = {YACA_PADDING_PKCS1, YACA_PADDING_PKCS1_PSS,
+                                            YACA_PADDING_X931, YACA_PADDING_PKCS1_SSLV23,
+                                            YACA_PADDING_PKCS1_OAEP};
+
+    for (yaca_block_cipher_mode_e bcm : bcms) {
+        enc_ctx = encrypt_init(YACA_ENCRYPT_AES, bcm, key_iv_pair.key, key_iv_pair.iv);
+
+        for (yaca_padding_e padding : paddings) {
+            YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_PADDING,
+                                                         (void*)(&padding), sizeof(padding)));
+        }
+    }
+}
+
+RUNNER_TEST(T3170_yaca_set_get_rc2_key_bits_invalid_param, YacaTest)
+{
+    size_t effective_key_bits;
+    size_t effective_key_bits_len;
+    KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_UNSAFE_128BIT);
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_UNSAFE_RC2, YACA_BCM_ECB, key, null_key());
+
+    effective_key_bits = 0;
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(),
+                                                 YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                 (void*)(&effective_key_bits),
+                                                 sizeof(effective_key_bits)));
+    effective_key_bits = 1025;
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(),
+                                                 YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                 (void*)(&effective_key_bits),
+                                                 sizeof(effective_key_bits)));
+
+    effective_key_bits = 128;
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(),
+                                                 YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                 (void*)(&effective_key_bits), sizeof(char)));
+
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(),
+                                                 YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                 (void**)(&effective_key_bits),
+                                                 &effective_key_bits_len));
+
+    size_t output_len = get_output_length(enc_ctx, DATA.size());
+    Buffer output(output_len);
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     output.data(), &output_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(),
+                                                 YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                 (void*)(&effective_key_bits),
+                                                 sizeof(effective_key_bits)));
+
+    std::vector<yaca_encrypt_algorithm_e> algos = {YACA_ENCRYPT_AES, YACA_ENCRYPT_UNSAFE_3DES_2TDEA,
+                                                   YACA_ENCRYPT_CAST5};
+
+    for (yaca_encrypt_algorithm_e algo : algos) {
+        enc_ctx = encrypt_init(algo, YACA_BCM_ECB, key, null_key());
+
+        YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(),
+                                                     YACA_PROPERTY_RC2_EFFECTIVE_KEY_BITS,
+                                                     (void*)(&effective_key_bits),
+                                                     sizeof(effective_key_bits)));
+    }
+}
+
+RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
+{
+    KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+    KeyPtr iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_128BIT);
+    KeyPtr gcm_iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_64BIT);
+
+    size_t aad_len = 16;
+    Buffer aad = random_buffer(aad_len);
+    size_t tag_len = 16;
+    char *tag;
+
+    size_t update_len, final_len;
+
+    // CTR
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CTR, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 aad.data(), aad.size()));
+
+    Buffer encrypt_output;
+    ChrPtr update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    ChrPtr final = out_buf_alloc(enc_ctx, 0, final_len);
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(tag_len)));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 (void**)&tag, &tag_len));
+
+    CtxPtr dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CTR, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 aad.data(), aad.size()));
+
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 tag, tag_len));
+
+    YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+
+    // GCM
+    enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, gcm_iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                                 aad.data(), aad.size()));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 (void**)aad.data(), &aad_len));
+
+    encrypt_output.clear();
+    update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    final = out_buf_alloc(enc_ctx, 0, final_len);
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(tag_len)));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(char)));
+
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 (void**)&tag, &tag_len));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 nullptr, &tag_len));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 (void**)&tag, nullptr));
+
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
+
+    dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, gcm_iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                                 aad.data(), aad.size()));
+    YACA_INVALID_PARAM(yaca_context_get_property(dec_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 (void**)aad.data(), &aad_len));
+
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 tag, tag_len));
+
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG, tag, tag_len));
+
+    YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+}
+
+RUNNER_TEST(T3190_yaca_set_get_ccm_properties_invalid_param, YacaTest)
+{
+    KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+    KeyPtr iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_64BIT);
+
+    size_t aad_len = 16;
+    Buffer aad = random_buffer(aad_len);
+    size_t tag_len = 12;
+    char *tag;
+
+    size_t update_len, final_len;
+
+    // CFB
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CFB, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(tag_len)));
+
+    YACA_INVALID_PARAM(yaca_encrypt_update(enc_ctx.get(), NULL, DATA.size(), NULL, &update_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                                 aad.data(), aad.size()));
+
+    Buffer encrypt_output;
+    ChrPtr update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    ChrPtr final = out_buf_alloc(enc_ctx, 0, final_len);
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 (void**)&tag, &tag_len));
+
+    CtxPtr dec_ctx = decrypt_init(YACA_ENCRYPT_3DES_3TDEA, YACA_BCM_CFB, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 tag, tag_len));
+    YACA_INVALID_PARAM(yaca_decrypt_update(dec_ctx.get(), NULL, encrypt_output.size(), NULL,
+                                           &update_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                                 aad.data(), aad.size()));
+
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+
+    // CCM
+    enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(tag_len)));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG_LEN,
+                                                 (void*)(&tag_len), sizeof(char)));
+
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), NULL, DATA.size(), NULL, &update_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 aad.data(), aad.size()));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                                 (void**)aad.data(), &aad_len));
+
+    YACA_SUCCESS(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                           aad.data(), aad.size()));
+
+    encrypt_output.clear();
+    update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    final = out_buf_alloc(enc_ctx, 0, final_len);
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 (void**)&tag, &tag_len));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 nullptr, &tag_len));
+    YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                                 (void**)&tag, nullptr));
+
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
+
+    dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                                 tag, tag_len));
+
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG, tag, tag_len));
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), NULL, encrypt_output.size(), NULL,
+                                     &update_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                                 aad.data(), aad.size()));
+
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                           aad.data(), aad.size()));
+
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+}
+
+RUNNER_TEST(T3200_yaca_set_invalid_gcm_tag_aad, YacaTest)
+{
+    KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+    KeyPtr iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_64BIT);
+
+    size_t aad_len = 16;
+    Buffer aad = random_buffer(aad_len);
+    size_t tag_len = 16;
+    char *tag;
+
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, iv);
+
+    Buffer encrypt_output;
+    size_t update_len, final_len;
+    ChrPtr update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    ChrPtr final = out_buf_alloc(enc_ctx, 0, final_len);
+
+    YACA_SUCCESS(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                           aad.data(), aad.size()));
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
+
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    CtxPtr dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, iv);
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+
+    // Invalid AAD
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_AAD, tag, aad.size()));
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+
+    // Valid TAG
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG, tag, tag_len));
+
+    YACA_INVALID_PARAM(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+
+    dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, iv);
+
+    // Valid AAD
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_AAD,
+                                           aad.data(), aad.size()));
+
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                     update.get(), &update_len));
+
+    // Invalid TAG
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                           aad.data(), tag_len));
+
+    YACA_INVALID_PARAM(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
+}
+
+RUNNER_TEST(T3210_yaca_set_invalid_ccm_tag_aad, YacaTest)
+{
+    KeyPtr key = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_192BIT);
+    KeyPtr iv = generate_key(YACA_KEY_TYPE_IV, YACA_KEY_LENGTH_IV_64BIT);
+
+    size_t aad_len = 16;
+    Buffer aad = random_buffer(aad_len);
+    size_t tag_len = 12;
+    char *tag;
+
+    CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
+
+    Buffer encrypt_output;
+    size_t update_len, final_len;
+    ChrPtr update = out_buf_alloc(enc_ctx, DATA.size(), update_len);
+    ChrPtr final = out_buf_alloc(enc_ctx, 0, final_len);
+
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), NULL, DATA.size(), NULL, &update_len));
+    YACA_SUCCESS(yaca_context_set_property(enc_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                           aad.data(), aad.size()));
+    YACA_SUCCESS(yaca_encrypt_update(enc_ctx.get(), DATA.data(), DATA.size(),
+                                     update.get(), &update_len));
+    YACA_SUCCESS(yaca_encrypt_finalize(enc_ctx.get(), final.get(), &final_len));
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                           (void**)&tag, &tag_len));
+    ChrPtr tag_ptr = wrap_ptr(tag);
+
+    encrypt_output.insert(encrypt_output.end(), update.get(), update.get() + update_len);
+    encrypt_output.insert(encrypt_output.end(), final.get(), final.get() + final_len);
+
+    CtxPtr dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
+    update = out_buf_alloc(dec_ctx, encrypt_output.size(), update_len);
+    final = out_buf_alloc(dec_ctx, 0, final_len);
+
+    // Invalid TAG
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                           aad.data(), tag_len));
+
+    // Valid AAD
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), NULL, encrypt_output.size(), NULL,
+                                     &update_len));
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                           aad.data(), aad.size()));
+
+    YACA_INVALID_PARAM(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                           update.get(), &update_len));
+
+    dec_ctx = decrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
+
+    // Valid TAG
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG, tag, tag_len));
+
+    // Invalid AAD
+    YACA_SUCCESS(yaca_decrypt_update(dec_ctx.get(), NULL, encrypt_output.size(), NULL,
+                                     &update_len));
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_AAD,
+                                           tag, aad.size()));
+
+    YACA_INVALID_PARAM(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
+                                           update.get(), &update_len));
+}

diff --git a/src/yaca/yaca-test-sign.cpp b/src/yaca/yaca-test-sign.cpp
index 0a8d77b..49a2d04 100644 (file)
--- a/src/yaca/yaca-test-sign.cpp
+++ b/src/yaca/yaca-test-sign.cpp
@@ -58,15 +58,21 @@ RUNNER_TEST_GROUP_INIT(T6000_YACA_SIGN);
 RUNNER_TEST(T6010_yaca_sign_init_invalid_param, YacaTest)
 {
     yaca_context_h ctx = YACA_CONTEXT_NULL;
-    KeyPtr prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
-    KeyPtr pub = extract_public_key(prv);
+    KeyPair rsa(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    KeyPair dsa(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPair ec(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP384R1);
     KeyPtr sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 
-    YACA_INVALID_PARAM(yaca_sign_initialize(nullptr, YACA_DIGEST_MD5, prv.get()));
-    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, static_cast<yaca_digest_algorithm_e>(-1), prv.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(nullptr, YACA_DIGEST_MD5, rsa.prv.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, static_cast<yaca_digest_algorithm_e>(-1),
+                                            rsa.prv.get()));
     YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, YACA_KEY_NULL));
-    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, pub.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, rsa.pub.get()));
     YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, sym.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_SHA384, rsa.prv.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_SHA512, rsa.prv.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, dsa.prv.get()));
+    YACA_INVALID_PARAM(yaca_sign_initialize(&ctx, YACA_DIGEST_MD5, ec.prv.get()));
 }
 
 RUNNER_TEST(T6020_yaca_sign_hmac_init_invalid_param, YacaTest)
@@ -124,15 +130,21 @@ RUNNER_TEST(T6050_yaca_sign_final_invalid_param, YacaTest)
 RUNNER_TEST(T6060_yaca_verify_init_invalid_param)
 {
     yaca_context_h ctx = YACA_CONTEXT_NULL;
-    KeyPtr prv = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
-    KeyPtr pub = extract_public_key(prv);
+    KeyPair rsa(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
+    KeyPair dsa(YACA_KEY_TYPE_DSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPair ec(YACA_KEY_TYPE_EC_PRIV, YACA_KEY_LENGTH_EC_SECP384R1);
     KeyPtr sym = generate_key(YACA_KEY_TYPE_SYMMETRIC, YACA_KEY_LENGTH_256BIT);
 
-    YACA_INVALID_PARAM(yaca_verify_initialize(nullptr, YACA_DIGEST_MD5, pub.get()));
-    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, static_cast<yaca_digest_algorithm_e>(-1), prv.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(nullptr, YACA_DIGEST_MD5, rsa.pub.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, static_cast<yaca_digest_algorithm_e>(-1),
+                                              rsa.prv.get()));
     YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, YACA_KEY_NULL));
-    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, prv.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, rsa.prv.get()));
     YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, sym.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_SHA384, rsa.pub.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_SHA512, rsa.pub.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, dsa.pub.get()));
+    YACA_INVALID_PARAM(yaca_verify_initialize(&ctx, YACA_DIGEST_MD5, ec.pub.get()));
 }
 
 RUNNER_TEST(T6070_yaca_verify_update_invalid_param)
@@ -141,9 +153,9 @@ RUNNER_TEST(T6070_yaca_verify_update_invalid_param)
     KeyPtr pub = extract_public_key(prv);
     CtxPtr ctx = verify_init(YACA_DIGEST_MD5, pub);
 
-    YACA_INVALID_PARAM(yaca_sign_update(YACA_CONTEXT_NULL, lorem16, LOREM16_SIZE));
-    YACA_INVALID_PARAM(yaca_sign_update(ctx.get(), nullptr, LOREM16_SIZE));
-    YACA_INVALID_PARAM(yaca_sign_update(ctx.get(), lorem16, 0));
+    YACA_INVALID_PARAM(yaca_verify_update(YACA_CONTEXT_NULL, lorem16, LOREM16_SIZE));
+    YACA_INVALID_PARAM(yaca_verify_update(ctx.get(), nullptr, LOREM16_SIZE));
+    YACA_INVALID_PARAM(yaca_verify_update(ctx.get(), lorem16, 0));
 }
 
 RUNNER_TEST(T6080_yaca_verify_final_invalid_param)
@@ -170,6 +182,30 @@ RUNNER_TEST(T6090_yaca_sign_get_output_length_invalid_param)
     YACA_INVALID_PARAM(yaca_context_get_output_length(ctx.get(), 0, nullptr));
 }
 
+RUNNER_TEST(T6095_yaca_sign_verify_call_order_invalid_param)
+{
+    KeyPtr key = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_1024BIT);
+    KeyPtr key_pub = extract_public_key(key);
+    CtxPtr ctx_sgn = sign_init(YACA_DIGEST_SHA1, key);
+    CtxPtr ctx_vrf = verify_init(YACA_DIGEST_SHA1, key_pub);
+    size_t output_len = get_output_length(ctx_sgn);
+    Buffer output(output_len);
+    yaca_padding_e padding = YACA_PADDING_PKCS1_PSS;
+
+    YACA_SUCCESS(yaca_sign_finalize(ctx_sgn.get(), output.data(), &output_len));
+    YACA_SUCCESS(yaca_verify_finalize(ctx_vrf.get(), output.data(), output_len));
+
+    YACA_INVALID_PARAM(yaca_sign_update(ctx_sgn.get(), output.data(), output_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(ctx_sgn.get(), YACA_PROPERTY_PADDING,
+                                                 static_cast<void*>(&padding),
+                                                 sizeof(yaca_padding_e)));
+
+    YACA_INVALID_PARAM(yaca_verify_update(ctx_vrf.get(), output.data(), output_len));
+    YACA_INVALID_PARAM(yaca_context_set_property(ctx_vrf.get(), YACA_PROPERTY_PADDING,
+                                                 static_cast<void*>(&padding),
+                                                 sizeof(yaca_padding_e)));
+}
+
 RUNNER_TEST(T6100_yaca_sign_set_property_invalid_param)
 {
     KeyPtr key = generate_key(YACA_KEY_TYPE_RSA_PRIV, YACA_KEY_LENGTH_512BIT);
@@ -205,6 +241,16 @@ RUNNER_TEST(T6100_yaca_sign_set_property_invalid_param)
                                                      0));
     }
 
+    padding = YACA_PADDING_X931;
+    ctx_sgn = sign_init(YACA_DIGEST_MD5, key);
+    YACA_INVALID_PARAM(yaca_context_set_property(ctx_sgn.get(), YACA_PROPERTY_PADDING,
+                                                 static_cast<void*>(&padding),
+                                                 sizeof(yaca_padding_e)));
+    ctx_sgn = sign_init(YACA_DIGEST_SHA224, key);
+    YACA_INVALID_PARAM(yaca_context_set_property(ctx_sgn.get(), YACA_PROPERTY_PADDING,
+                                                 static_cast<void*>(&padding),
+                                                 sizeof(yaca_padding_e)));
+
     YACA_INVALID_PARAM(yaca_context_set_property(ctx_dsa.get(), YACA_PROPERTY_PADDING,
                                                  static_cast<void*>(&padding),
                                                  sizeof(yaca_padding_e)));
@@ -214,7 +260,6 @@ RUNNER_TEST(T6100_yaca_sign_set_property_invalid_param)
     YACA_INVALID_PARAM(yaca_context_set_property(ctx_digest.get(), YACA_PROPERTY_PADDING,
                                                  static_cast<void*>(&padding),
                                                  sizeof(yaca_padding_e)));
-
 }
 
 RUNNER_TEST(T6120_yaca_sign_get_output_length)
@@ -229,7 +274,6 @@ RUNNER_TEST(T6120_yaca_sign_get_output_length)
     };
 
     const std::vector<yaca_key_bit_length_e> lengths = {
-        YACA_KEY_LENGTH_512BIT,
         YACA_KEY_LENGTH_1024BIT,
         YACA_KEY_LENGTH_2048BIT,
         YACA_KEY_LENGTH_3072BIT,
@@ -495,7 +539,8 @@ RUNNER_TEST(T6180_yaca_sign_verify_padding_test_vectors, YacaTest)
             CtxPtr ctx = sign_init(algo, key_prv);
             size_t output_len = get_output_length(ctx);
             YACA_SUCCESS(yaca_context_set_property(ctx.get(), YACA_PROPERTY_PADDING,
-                                                   static_cast<void*>(&padding), sizeof(padding)));
+                                                   static_cast<void*>(&padding),
+                                                   sizeof(yaca_padding_e)));
 
             if (input.size() > 0) {
                 for (size_t i = 0; i < repeats; i++)
@@ -510,7 +555,8 @@ RUNNER_TEST(T6180_yaca_sign_verify_padding_test_vectors, YacaTest)
 
             ctx = verify_init(algo, key_pub);
             YACA_SUCCESS(yaca_context_set_property(ctx.get(), YACA_PROPERTY_PADDING,
-                                                   static_cast<void*>(&padding), sizeof(padding)));
+                                                   static_cast<void*>(&padding),
+                                                   sizeof(yaca_padding_e)));
 
             if (input.size() > 0)
                 for (size_t i = 0; i < repeats; i++)
@@ -555,3 +601,32 @@ RUNNER_TEST(T6180_yaca_sign_verify_padding_test_vectors, YacaTest)
         }
     }
 }
+
+RUNNER_TEST(T6190_yaca_sign_param_combinations, YacaTest)
+{
+    auto tvv = loadTestVector("sign_param_comb.txt");
+
+    for (const auto& tv : tvv) {
+        yaca_key_type_e key_type;
+        size_t key_len;
+        yaca_padding_e padding;
+        yaca_digest_algorithm_e algo;
+
+        tv.get("key_type", key_type);
+        tv.get("key_len_bits", key_len);
+        if (key_type == YACA_KEY_TYPE_RSA_PRIV)
+            tv.get("padding", padding);
+        tv.get("algo", algo);
+
+        KeyPtr key = generate_key(key_type, key_len);
+        CtxPtr ctx = sign_init(algo, key);
+
+        if (key_type == YACA_KEY_TYPE_RSA_PRIV)
+           YACA_SUCCESS(yaca_context_set_property(ctx.get(), YACA_PROPERTY_PADDING,
+                                                  (void*)&padding, sizeof(yaca_padding_e)));
+
+        size_t output_len = get_output_length(ctx);
+        Buffer output(output_len);
+        YACA_SUCCESS(yaca_sign_finalize(ctx.get(), output.data(), &output_len));
+    }
+}

diff --git a/src/yaca/yaca-test-vector.cpp b/src/yaca/yaca-test-vector.cpp
index b145a67..49b8b51 100644 (file)
--- a/src/yaca/yaca-test-vector.cpp
+++ b/src/yaca/yaca-test-vector.cpp
@@ -120,6 +120,16 @@ std::unordered_map<std::string, yaca_kdf_e> str2kdf = {
     std::make_pair("X962", YACA_KDF_X962)
 };
 
+std::unordered_map<std::string, yaca_padding_e> str2padding = {
+    std::make_pair("NONE",         YACA_PADDING_NONE),
+    std::make_pair("X931",         YACA_PADDING_X931),
+    std::make_pair("PKCS1",        YACA_PADDING_PKCS1),
+    std::make_pair("PKCS1_PSS",    YACA_PADDING_PKCS1_PSS),
+    std::make_pair("PKCS1_OAEP",   YACA_PADDING_PKCS1_OAEP),
+    std::make_pair("PKCS1_SSLV23", YACA_PADDING_PKCS1_SSLV23),
+    std::make_pair("PKCS7",        YACA_PADDING_PKCS7)
+};
+
 } // anonymous namespace
 
 void TestVector::add(const std::string &key, const std::string &val)
@@ -174,6 +184,11 @@ void TestVector::get(const std::string &key, yaca_kdf_e &val) const
     val = str2kdf.at(value(key));
 }
 
+void TestVector::get(const std::string &key, yaca_padding_e &val) const
+{
+    val = str2padding.at(value(key));
+}
+
 void TestVector::reset()
 {
     m_data.clear();

diff --git a/src/yaca/yaca-test-vector.h b/src/yaca/yaca-test-vector.h
index 1e34481..06ee01b 100644 (file)
--- a/src/yaca/yaca-test-vector.h
+++ b/src/yaca/yaca-test-vector.h
@@ -57,6 +57,8 @@ public:
     void get(const std::string &key, yaca_block_cipher_mode_e &val) const;
     /* special case for kdf */
     void get(const std::string &key, yaca_kdf_e &val) const;
+    /* special case for padding */
+    void get(const std::string &key, yaca_padding_e &val) const;
 
     void reset();