projects / platform / core / test / security-tests.git / commitdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: df065fe)
YACA: Add get/set_property invalid param tests 67/87767/7
authorDariusz Michaluk <d.michaluk@samsung.com>
Wed, 14 Sep 2016 12:01:52 +0000 (14:01 +0200)
committerDariusz Michaluk <d.michaluk@samsung.com>
Wed, 28 Sep 2016 13:14:38 +0000 (15:14 +0200)
Change-Id: I41a6138ed079958fd7d5b36ba357f589b49776f9

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 d27cc5e0f8aebba3283097a4df66e504730ae95e..60a3ae1723cb5921de9ed5f70ea7bbb634380575 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)
@@ -1053,3 +1053,300 @@ 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 = 12;
+    ChrPtr tag = create_yaca_buffer(tag_len);
+
+    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.get(), &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.get(), 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.get(), &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));
+
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                           (void**)tag.get(), &tag_len));
+
+    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.get(), tag_len));
+
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_GCM_TAG,
+                                           tag.get(), 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;
+    ChrPtr tag = create_yaca_buffer(tag_len);
+
+    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.get(), &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));
+    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.get(), &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));
+
+    YACA_SUCCESS(yaca_context_get_property(enc_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                           (void**)tag.get(), &tag_len));
+
+    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));
+
+    YACA_SUCCESS(yaca_context_set_property(dec_ctx.get(), YACA_PROPERTY_CCM_TAG,
+                                           tag.get(), 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));
+}
Domain: Security / Uncategorized;