summaryrefslogtreecommitdiff
path: root/tests/internals.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/internals.cpp')
-rw-r--r--tests/internals.cpp325
1 files changed, 163 insertions, 162 deletions
diff --git a/tests/internals.cpp b/tests/internals.cpp
index 257447b..b5c106d 100644
--- a/tests/internals.cpp
+++ b/tests/internals.cpp
@@ -22,6 +22,7 @@
*/
#include "web_app_enc.h"
+#include <string>
#include <cstring>
#include <unistd.h>
@@ -32,6 +33,51 @@
#include "test-common.h"
+namespace {
+
+using rb_raii = std::unique_ptr<raw_buffer_s, void(*)(raw_buffer_s *)>;
+using ce_raii = std::unique_ptr<crypto_element_s, void(*)(crypto_element_s *)>;
+using map_raii = std::unique_ptr<crypto_element_map_s, void(*)(crypto_element_map_s *)>;
+
+inline rb_raii _safe(raw_buffer_s *ptr)
+{
+ return rb_raii(ptr, buffer_destroy);
+}
+
+inline ce_raii _safe(crypto_element_s *ptr)
+{
+ return ce_raii(ptr, crypto_element_destroy);
+}
+
+inline map_raii _safe(crypto_element_map_s *ptr)
+{
+ return map_raii(ptr, crypto_element_map_destroy);
+}
+
+crypto_element_s *_create_ce(void)
+{
+ raw_buffer_s *dek = buffer_create(32);
+ raw_buffer_s *iv = buffer_create(16);
+ crypto_element_s *ce = crypto_element_create(dek, iv);
+
+ if (ce == nullptr) {
+ buffer_destroy(dek);
+ buffer_destroy(iv);
+ } else if (_get_random(ce->dek) != WAE_ERROR_NONE) {
+ crypto_element_destroy(ce);
+ ce = nullptr;
+ } else if (_get_random(ce->iv) != WAE_ERROR_NONE) {
+ crypto_element_destroy(ce);
+ ce = nullptr;
+ }
+
+ BOOST_REQUIRE(ce != nullptr);
+
+ return ce;
+}
+
+}
+
BOOST_AUTO_TEST_SUITE(SYSTEM)
BOOST_AUTO_TEST_SUITE(INTERNALS)
@@ -78,29 +124,37 @@ BOOST_AUTO_TEST_CASE(encrypt_decrypt_app_dek)
"+wIDAQAB\n"
"-----END PUBLIC KEY-----";
- std::vector<unsigned char> dek(32, 0);
+ raw_buffer_s *dek = buffer_create(32);
+
+ auto _raii1 = _safe(dek);
+
+ BOOST_REQUIRE_MESSAGE(dek != nullptr && dek->size == 32, "Failed to create buffer");
+ BOOST_REQUIRE_MESSAGE(_get_random(dek) == WAE_ERROR_NONE, "Failed to get random");
+
+ raw_buffer_s pubkey;
+
+ pubkey.buf = (unsigned char *)public_key;
+ pubkey.size = strlen(public_key);
+
+ raw_buffer_s *encrypted = nullptr;
+ int ret = encrypt_app_dek(&pubkey, dek, &encrypted);
- unsigned char *_encrypted = nullptr;
- size_t _encrypted_len = 0;
- int ret = encrypt_app_dek(reinterpret_cast<const unsigned char *>(public_key),
- strlen(public_key), dek.data(), dek.size(), &_encrypted,
- &_encrypted_len);
- auto encrypted = Wae::Test::bytearr_to_vec(_encrypted, _encrypted_len);
- free(_encrypted);
+ auto _raii2 = _safe(encrypted);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to encrypt_app_dek. ec: " << ret);
- unsigned char *_decrypted = nullptr;
- size_t _decrypted_len = 0;
- ret = decrypt_app_dek(reinterpret_cast<const unsigned char *>(private_key),
- strlen(private_key), nullptr, encrypted.data(), encrypted.size(),
- &_decrypted, &_decrypted_len);
- auto decrypted = Wae::Test::bytearr_to_vec(_decrypted, _decrypted_len);
- free(_decrypted);
+ raw_buffer_s prikey;
+ prikey.buf = (unsigned char *)private_key;
+ prikey.size = strlen(private_key);
+
+ raw_buffer_s *decrypted = nullptr;
+ ret = decrypt_app_dek(&prikey, nullptr, encrypted, &decrypted);
+
+ auto _raii3 = _safe(decrypted);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to decrypt_app_dek. ec: " << ret);
- BOOST_REQUIRE_MESSAGE(dek == decrypted,
+ BOOST_REQUIRE_MESSAGE(Wae::Test::bytes_to_hex(dek) == Wae::Test::bytes_to_hex(decrypted),
"encrypted/decrypted dek isn't valid. "
"dek(" << Wae::Test::bytes_to_hex(dek) << ") "
"decrypted(" << Wae::Test::bytes_to_hex(decrypted) << ")");
@@ -108,37 +162,32 @@ BOOST_AUTO_TEST_CASE(encrypt_decrypt_app_dek)
BOOST_AUTO_TEST_CASE(encrypt_decrypt_aes_cbc)
{
- std::vector<unsigned char> plaintext = {
- 'a', 'b', 'c', 'a', 'b', 'c', 'x', 'y',
- 'o', 'q', '2', 'e', 'v', '0', '1', 'x'
- };
+ raw_buffer_s *data = buffer_create(16);
+
+ auto _raii1 = _safe(data);
- size_t dek_len = 32;
- std::vector<unsigned char> dek(dek_len, 0);
+ BOOST_REQUIRE_MESSAGE(data != nullptr && data->size == 16, "Failed to create buffer");
- int ret = _get_random(dek.size(), dek.data());
- BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get random");
+ crypto_element_s *ce = _create_ce();
- unsigned char *_encrypted = nullptr;
- size_t _encrypted_len = 0;
- ret = encrypt_aes_cbc(dek.data(), dek.size(), plaintext.data(), plaintext.size(),
- &_encrypted, &_encrypted_len);
- auto encrypted = Wae::Test::bytearr_to_vec(_encrypted, _encrypted_len);
- free(_encrypted);
+ auto _raii2 = _safe(ce);
+
+ raw_buffer_s *encrypted = nullptr;
+ int ret = encrypt_aes_cbc(ce, data, &encrypted);
+
+ auto _raii3 = _safe(encrypted);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to encrypt_aes_cbc. ec: " << ret);
- unsigned char *_decrypted = nullptr;
- size_t _decrypted_len = 0;
- ret = decrypt_aes_cbc(dek.data(), dek.size(), encrypted.data(), encrypted.size(),
- &_decrypted, &_decrypted_len);
- auto decrypted = Wae::Test::bytearr_to_vec(_decrypted, _decrypted_len);
- free(_decrypted);
+ raw_buffer_s *decrypted = nullptr;
+ ret = decrypt_aes_cbc(ce, encrypted, &decrypted);
+
+ auto _raii4 = _safe(decrypted);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to decrypt_aes_cbc. ec: " << ret);
- BOOST_REQUIRE_MESSAGE(plaintext == decrypted,
+ BOOST_REQUIRE_MESSAGE(Wae::Test::bytes_to_hex(data) == Wae::Test::bytes_to_hex(decrypted),
"decrypted plaintext isn't valid. "
- "plaintext(" << Wae::Test::bytes_to_hex(plaintext) << ") "
+ "plaintext(" << Wae::Test::bytes_to_hex(data) << ") "
"decrypted(" << Wae::Test::bytes_to_hex(decrypted) << ")");
}
@@ -149,90 +198,79 @@ BOOST_AUTO_TEST_CASE(cache)
const char *pkg3 = "pkg3";
const char *pkgDummy = "dummy";
- std::vector<unsigned char> dek1(32, 1);
- std::vector<unsigned char> dek2(32, 2);
- std::vector<unsigned char> dek3(32, 3);
+ auto ce1 = _create_ce();
+ auto ce2 = _create_ce();
+ auto ce3 = _create_ce();
- _initialize_cache();
+ crypto_element_map_s *map = nullptr;
- _add_app_dek_to_cache(pkg1, dek1.data());
- _add_app_dek_to_cache(pkg2, dek2.data());
- _add_app_dek_to_cache(pkg3, dek3.data());
+ int tmp = crypto_element_map_add(&map, pkg1, ce1);
+ BOOST_REQUIRE_MESSAGE(tmp == WAE_ERROR_NONE, "Failed to add ce to map. ret: " << tmp);
- size_t dek_len = 32;
- const unsigned char *_cached = _get_app_dek_from_cache(pkg1);
- auto cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
+ tmp = crypto_element_map_add(&map, pkg2, ce2);
+ BOOST_REQUIRE_MESSAGE(tmp == WAE_ERROR_NONE, "Failed to add ce to map. ret: " << tmp);
- BOOST_REQUIRE_MESSAGE(cached == dek1,
- "cached dek isn't valid! "
- "dek(" << Wae::Test::bytes_to_hex(dek1) << ") "
- "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
+ tmp = crypto_element_map_add(&map, pkg3, ce3);
+ BOOST_REQUIRE_MESSAGE(tmp == WAE_ERROR_NONE, "Failed to add ce to map. ret: " << tmp);
- _cached = _get_app_dek_from_cache(pkg2);
- cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkg1) == ce1,
+ "cached ce has different address with actual.");
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkg2) == ce2,
+ "cached ce has different address with actual.");
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkg3) == ce3,
+ "cached ce has different address with actual.");
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkgDummy) == nullptr,
+ "something returned with pkg dummy from map which should be null.");
- BOOST_REQUIRE_MESSAGE(cached == dek2,
- "cached dek isn't valid! "
- "dek(" << Wae::Test::bytes_to_hex(dek2) << ") "
- "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
+ crypto_element_map_remove(&map, pkg3);
- _cached = _get_app_dek_from_cache(pkg3);
- cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkg3) == nullptr,
+ "removed pkg(" << pkg3 << ") is returned from map which should be null.");
- BOOST_REQUIRE_MESSAGE(cached == dek3,
- "cached dek isn't valid! "
- "dek(" << Wae::Test::bytes_to_hex(dek3) << ") "
- "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
+ auto ce4 = _create_ce();
+ tmp = crypto_element_map_add(&map, pkg1, ce4);
+ BOOST_REQUIRE_MESSAGE(tmp == WAE_ERROR_NONE, "Failed to update ce to map. ret: " << tmp);
- _cached = _get_app_dek_from_cache(pkgDummy);
- if (_cached) {
- cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
- BOOST_REQUIRE_MESSAGE(false,
- "wrong cached val is extracted by dummy pkg id. "
- "val(" << Wae::Test::bytes_to_hex(cached) << ")");
- }
+ BOOST_REQUIRE_MESSAGE(crypto_element_map_get(map, pkg1) == ce4,
+ "cached ce has different address with actual.");
- _remove_app_dek_from_cache(pkg3);
+ crypto_element_map_destroy(map);
+}
- _cached = _get_app_dek_from_cache(pkg3);
- if (_cached) {
- cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
- BOOST_REQUIRE_MESSAGE(false,
- "app dek removed from cache but it's remained! "
- "val(" << Wae::Test::bytes_to_hex(cached) << ")");
- }
+BOOST_AUTO_TEST_CASE(cache_max)
+{
+ crypto_element_map_s *map = nullptr;
- _initialize_cache();
+ for (size_t i = 0; i < MAX_MAP_ELEMENT_SIZE + 1; ++i) {
+ BOOST_REQUIRE(crypto_element_map_add(&map, std::to_string(i).c_str(), _create_ce()) == WAE_ERROR_NONE);
+ }
- _add_app_dek_to_cache(pkg1, dek1.data());
+ BOOST_REQUIRE(crypto_element_map_get(map, "0") == nullptr);
- _cached = nullptr;
- _cached = _get_app_dek_from_cache(pkg2);
- if (_cached) {
- cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
- BOOST_REQUIRE_MESSAGE(false,
- "cache is initialized but something is remained! "
- "val(" << Wae::Test::bytes_to_hex(cached) << ")");
- }
+ crypto_element_map_destroy(map);
}
BOOST_AUTO_TEST_CASE(read_write_encrypted_app_dek)
{
const char *pkg_id = "write_test_pkg";
- std::vector<unsigned char> dek(256, 0);
+ raw_buffer_s *dek = buffer_create(256);
- int ret = _write_encrypted_app_dek_to_file(pkg_id, dek.data(), dek.size());
+ auto raii1 = _safe(dek);
+
+ BOOST_REQUIRE(dek != nullptr);
+ BOOST_REQUIRE(_get_random(dek) == WAE_ERROR_NONE);
+
+ int ret = _write_encrypted_app_dek_to_file(pkg_id, dek);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to write_encrypted_app_dek_to_file. ec: " << ret);
- unsigned char *_readed = nullptr;
- size_t _readed_len = 0;
- ret = _read_encrypted_app_dek_from_file(pkg_id, &_readed, &_readed_len);
- auto readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
- free(_readed);
+ raw_buffer_s *readed = nullptr;
+ ret = _read_encrypted_app_dek_from_file(pkg_id, &readed);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to read_encrypted_app_dek_from_file. ec: " << ret);
- BOOST_REQUIRE_MESSAGE(dek == readed,
+ auto raii2 = _safe(readed);
+
+ BOOST_REQUIRE_MESSAGE(Wae::Test::bytes_to_hex(dek) == Wae::Test::bytes_to_hex(readed),
"dek isn't match after write/read file. "
"dek(" << Wae::Test::bytes_to_hex(dek) << ") "
"readed(" << Wae::Test::bytes_to_hex(readed) << ")");
@@ -242,35 +280,23 @@ BOOST_AUTO_TEST_CASE(get_create_preloaded_app_dek_1)
{
const char *pkg_id = "TEST_PKG_ID_FOR_CREATE";
- unsigned char *_readed = nullptr;
- size_t _readed_len = 0;
- int ret = get_preloaded_app_dek(pkg_id, &_readed, &_readed_len);
- auto readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
- free(_readed);
+ const crypto_element_s *readed = nullptr;
+ int ret = get_preloaded_app_ce(pkg_id, &readed);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NO_KEY,
- "preloaded app dek to create is already exist. ec: " << ret);
+ "preloaded app ce to create is already exist. ec: " << ret);
- unsigned char *_dek = nullptr;
- size_t _dek_len = 0;
- ret = create_preloaded_app_dek(pkg_id, &_dek, &_dek_len);
- auto dek = Wae::Test::bytearr_to_vec(_dek, _dek_len);
+ const crypto_element_s *ce = nullptr;
+ ret = create_preloaded_app_ce(pkg_id, &ce);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed to create_preloaded_app_dek. ec: " << ret);
-
- _readed = nullptr;
- ret = get_preloaded_app_dek(pkg_id, &_readed, &_readed_len);
- readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
- free(_readed);
+ "Failed to create_preloaded_app_ce. ec: " << ret);
+ ret = get_preloaded_app_ce(pkg_id, &readed);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed to get_preloaded_app_dek. ec: " << ret);
+ "Failed to get_preloaded_app_ce. ec: " << ret);
- BOOST_REQUIRE_MESSAGE(dek == readed,
- "created/loaded dek is not matched! "
- "created(" << Wae::Test::bytes_to_hex(dek) << ") "
- "loaded(" << Wae::Test::bytes_to_hex(readed) << ")");
+ BOOST_REQUIRE_MESSAGE(readed == ce, "cached ce address and actual is different!");
}
BOOST_AUTO_TEST_CASE(get_create_preloaded_app_dek_2)
@@ -284,67 +310,42 @@ BOOST_AUTO_TEST_CASE(get_create_preloaded_app_dek_2)
_get_preloaded_app_dek_file_path(pkg_id2, sizeof(path2), path2);
// remove old test data
- remove_app_dek(pkg_id1, WAE_PRELOADED_APP);
- remove_app_dek(pkg_id2, WAE_PRELOADED_APP);
+ remove_app_ce(pkg_id1, WAE_PRELOADED_APP);
+ remove_app_ce(pkg_id2, WAE_PRELOADED_APP);
unlink(path1);
unlink(path2);
- // create 2 deks for preloaded app
- unsigned char *_dek1 = nullptr;
- size_t _dek_len1 = 0;
- int ret = create_preloaded_app_dek(pkg_id1, &_dek1, &_dek_len1);
- auto dek1 = Wae::Test::bytearr_to_vec(_dek1, _dek_len1);
- free(_dek1);
-
+ // create 2 ces for preloaded app
+ const crypto_element_s *ce1 = nullptr;
+ int ret = create_preloaded_app_ce(pkg_id1, &ce1);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed to create_preloaded_app_dek. ec: " << ret);
-
- unsigned char *_dek2 = nullptr;
- size_t _dek_len2 = 0;
- ret = create_preloaded_app_dek(pkg_id2, &_dek2, &_dek_len2);
- auto dek2 = Wae::Test::bytearr_to_vec(_dek2, _dek_len2);
- free(_dek2);
+ "Failed to create_preloaded_app_ce. ec: " << ret);
+ const crypto_element_s *ce2 = nullptr;
+ ret = create_preloaded_app_ce(pkg_id2, &ce2);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed to create_preloaded_app_dek. ec: " << ret);
+ "Failed to create_preloaded_app_ce. ec: " << ret);
ret = load_preloaded_app_deks(true);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
"Failed to load_preloaded_app_deks. ec: " << ret);
- unsigned char *_readed1 = nullptr;
- size_t _readed_len1 = 0;
- ret = get_app_dek(pkg_id1, WAE_PRELOADED_APP, &_readed1, &_readed_len1);
- auto readed1 = Wae::Test::bytearr_to_vec(_readed1, _readed_len1);
- free(_readed1);
-
+ const crypto_element_s *readed1 = nullptr;
+ ret = get_app_ce(pkg_id1, WAE_PRELOADED_APP, false, &readed1);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get_app_dek. ec: " << ret);
- unsigned char *_readed2 = nullptr;
- size_t _readed_len2 = 0;
- ret = get_app_dek(pkg_id2, WAE_PRELOADED_APP, &_readed2, &_readed_len2);
- auto readed2 = Wae::Test::bytearr_to_vec(_readed2, _readed_len2);
- free(_readed2);
-
+ const crypto_element_s *readed2 = nullptr;
+ ret = get_app_ce(pkg_id2, WAE_PRELOADED_APP, false, &readed2);
BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get_app_dek. ec: " << ret);
- BOOST_REQUIRE_MESSAGE(dek1 == readed1,
- "readed dek and original isn't matched! "
- "original(" << Wae::Test::bytes_to_hex(dek1) << ") "
- "readed(" << Wae::Test::bytes_to_hex(readed1) << ")");
+ BOOST_REQUIRE_MESSAGE(readed1 == ce1, "cached ce and actual address is different!");
+ BOOST_REQUIRE_MESSAGE(readed2 == ce2, "cached ce and actual address is different!");
- BOOST_REQUIRE_MESSAGE(dek2 == readed2,
- "readed dek and original isn't matched! "
- "original(" << Wae::Test::bytes_to_hex(dek2) << ") "
- "readed(" << Wae::Test::bytes_to_hex(readed2) << ")");
+ ret = remove_app_ce(pkg_id1, WAE_PRELOADED_APP);
+ BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed remove app ce. ec: " << ret);
- ret = remove_app_dek(pkg_id1, WAE_PRELOADED_APP);
- BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed remove app dek after used. ec: " << ret);
-
- ret = remove_app_dek(pkg_id2, WAE_PRELOADED_APP);
- BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
- "Failed remove app dek after used. ec: " << ret);
+ ret = remove_app_ce(pkg_id2, WAE_PRELOADED_APP);
+ BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed remove app ce. ec: " << ret);
}
BOOST_AUTO_TEST_SUITE_END() // INTERNALS