projects / platform / core / test / security-tests.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: 1d77499)
Adjust tests after yaca_context_get_property() implementation fix 66/160166/1
authorDariusz Michaluk <d.michaluk@samsung.com>
Tue, 14 Nov 2017 18:07:14 +0000 (19:07 +0100)
committerDariusz Michaluk <d.michaluk@samsung.com>
Tue, 14 Nov 2017 18:07:14 +0000 (19:07 +0100)
Change-Id: I3f0e8a2039db5df8d0d704f3b76066a2f395f0bf

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

diff --git a/src/yaca/yaca-test-encrypt.cpp b/src/yaca/yaca-test-encrypt.cpp
index 749cd0d..9ab048f 100644 (file)
--- a/src/yaca/yaca-test-encrypt.cpp
+++ b/src/yaca/yaca-test-encrypt.cpp
@@ -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
@@ -802,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;
@@ -816,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)));
 
@@ -832,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)));
 
@@ -844,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)));
 
@@ -859,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)));
 
@@ -875,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);
@@ -888,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");
@@ -903,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;
@@ -916,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)));
 
@@ -935,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);
@@ -947,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);
@@ -961,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));
@@ -982,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);
@@ -994,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");
@@ -1172,7 +1175,7 @@ RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
     size_t aad_len = 16;
     Buffer aad = random_buffer(aad_len);
     size_t tag_len = 16;
-    ChrPtr tag = create_yaca_buffer(tag_len);
+    char *tag;
 
     size_t update_len, final_len;
 
@@ -1193,7 +1196,7 @@ RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
     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.get(), &tag_len));
+                                                 (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,
@@ -1206,7 +1209,7 @@ RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
                                      update.get(), &update_len));
 
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
 
     YACA_SUCCESS(yaca_decrypt_finalize(dec_ctx.get(), final.get(), &final_len));
 
@@ -1232,14 +1235,15 @@ RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
                                                  (void*)(&tag_len), sizeof(char)));
 
     YACA_INVALID_PARAM(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
-                                                 (void**)tag.get(), &tag_len));
+                                                 (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.get(), nullptr));
+                                                 (void**)&tag, nullptr));
 
     YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
-                                           (void**)tag.get(), &tag_len));
+                                           (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,
@@ -1254,10 +1258,9 @@ RUNNER_TEST(T3180_yaca_set_get_gcm_properties_invalid_param, YacaTest)
                                      update.get(), &update_len));
 
     YACA_INVALID_PARAM(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
-                                                 tag.get(), tag_len));
+                                                 tag, tag_len));
 
-    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
-                                           tag.get(), 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));
 }
@@ -1270,7 +1273,7 @@ RUNNER_TEST(T3190_yaca_set_get_ccm_properties_invalid_param, YacaTest)
     size_t aad_len = 16;
     Buffer aad = random_buffer(aad_len);
     size_t tag_len = 12;
-    ChrPtr tag = create_yaca_buffer(tag_len);
+    char *tag;
 
     size_t update_len, final_len;
 
@@ -1293,11 +1296,11 @@ RUNNER_TEST(T3190_yaca_set_get_ccm_properties_invalid_param, YacaTest)
     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.get(), &tag_len));
+                                                 (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.get(), tag_len));
+                                                 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,
@@ -1336,21 +1339,21 @@ RUNNER_TEST(T3190_yaca_set_get_ccm_properties_invalid_param, YacaTest)
     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.get(), &tag_len));
+                                                 (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.get(), nullptr));
+                                                 (void**)&tag, nullptr));
 
     YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
-                                           (void**)tag.get(), &tag_len));
+                                           (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.get(), tag_len));
+                                                 tag, tag_len));
 
-    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
-                                           tag.get(), 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));
@@ -1375,7 +1378,7 @@ RUNNER_TEST(T3200_yaca_set_invalid_gcm_tag_aad, YacaTest)
     size_t aad_len = 16;
     Buffer aad = random_buffer(aad_len);
     size_t tag_len = 16;
-    ChrPtr tag = create_yaca_buffer(tag_len);
+    char *tag;
 
     CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_GCM, key, iv);
 
@@ -1390,7 +1393,8 @@ RUNNER_TEST(T3200_yaca_set_invalid_gcm_tag_aad, YacaTest)
                                      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.get(), &tag_len));
+                                           (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);
@@ -1400,15 +1404,13 @@ RUNNER_TEST(T3200_yaca_set_invalid_gcm_tag_aad, YacaTest)
     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.get(), aad.size()));
+    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.get(), tag_len));
+    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));
 
@@ -1436,7 +1438,7 @@ RUNNER_TEST(T3210_yaca_set_invalid_ccm_tag_aad, YacaTest)
     size_t aad_len = 16;
     Buffer aad = random_buffer(aad_len);
     size_t tag_len = 12;
-    ChrPtr tag = create_yaca_buffer(tag_len);
+    char *tag;
 
     CtxPtr enc_ctx = encrypt_init(YACA_ENCRYPT_AES, YACA_BCM_CCM, key, iv);
 
@@ -1452,7 +1454,8 @@ RUNNER_TEST(T3210_yaca_set_invalid_ccm_tag_aad, YacaTest)
                                      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.get(), &tag_len));
+                                           (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);
@@ -1477,14 +1480,13 @@ RUNNER_TEST(T3210_yaca_set_invalid_ccm_tag_aad, YacaTest)
     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.get(), tag_len));
+    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.get(), aad.size()));
+                                           tag, aad.size()));
 
     YACA_INVALID_PARAM(yaca_decrypt_update(dec_ctx.get(), encrypt_output.data(), encrypt_output.size(),
                                            update.get(), &update_len));
Domain: Security / Uncategorized;