tests/internals.cpp

   1 /*
   2  *  Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *  Licensed under the Apache License, Version 2.0 (the "License");
   5  *  you may not use this file except in compliance with the License.
   6  *  You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *  Unless required by applicable law or agreed to in writing, software
  11  *  distributed under the License is distributed on an "AS IS" BASIS,
  12  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *  See the License for the specific language governing permissions and
  14  *  limitations under the License
  15  *
  16  *
  17  * @file        internals.cpp
  18  * @author      Dongsun Lee (ds73.lee@samsung.com)
  19  *              Kyungwook Tak (k.tak@samsung.com)
  20  * @version     2.0
  21  * @brief       internal functions test
  22  */
  23 #include "web_app_enc.h"
  24
  25 #include <cstring>
  26 #include <unistd.h>
  27
  28 #include <boost/test/unit_test.hpp>
  29
  30 #include "key_handler.h"
  31 #include "crypto_service.h"
  32
  33 #include "test-common.h"
  34
  35 BOOST_AUTO_TEST_SUITE(SYSTEM)
  36
  37 BOOST_AUTO_TEST_SUITE(INTERNALS)
  38
  39 BOOST_AUTO_TEST_CASE(encrypt_decrypt_app_dek)
  40 {
  41         const char *private_key =
  42                 "-----BEGIN RSA PRIVATE KEY-----\n"
  43                 "MIIEpgIBAAKCAQEA0kWtjpRO7Zh2KX2naVE/BDJdrfwK9xexfNA0MkY2VJ4J2AKM\n"
  44                 "YTj1D1jntceryupCEHOvP3rum+WsFvPXduz9+VKnSsSqj4jcTUubtpDUGA5G79Iq\n"
  45                 "LEPFuSBaqI8Uwkzd08pE+s30oaJDnNazMhSq8JkqBPoCCwtUs73ruE9VbtsBO/kT\n"
  46                 "lASIAfe8nXqcJLcDQgWYhizjJw0Pi6d74oCwS2OTvQDNvsXfFnA0ZJEEYw/rZLir\n"
  47                 "j7OHoOjz+Sh5N+1uA3Up6SPPEbHuP6L12YxqHdy7gnJXodLhvE/cR4SN9VW7+qmC\n"
  48                 "MBjmLkBejGrEX3STS9sLI7MZHu9Y26dwuYb4+wIDAQABAoIBAQCwxqV/vc2RUGDe\n"
  49                 "xuXM0+IvrAw37jJlw4SS0xNexMp+XxMViCbuwYy851h96azS/himbiuCKd6aL/96\n"
  50                 "mGunbtyiFEvSvv5Jh5z2Wr9BQAcfZjla+4w7BIsg9UNifE/OfgLsQBu34xhsHtfK\n"
  51                 "7nFehCOl/I5n+qtnD5KZPe0DWacQdwY4vEAj6YyXdb2bBg+MiwE9KVxGEIUDbklh\n"
  52                 "Is70JXczjLZCS+lIpOKh0/lbZmBZePoUbVTtS+GvtPTpQC/aTHRkwGoEtuPEWpbL\n"
  53                 "0Q1d6zO+vDJVLJlb5FF2haghs8IlqAxkkPjeUTNye+WktRrDQxmPu/blbxQrygfq\n"
  54                 "Au5tBnsxAoGBAOiVtcpg32puo3Yq2Y78oboe9PuHaQP0d3DhwP3/7J0BeNslpjW7\n"
  55                 "E1LWsVsCanxTE8XPUdFfAWgMk7lQqESN0wawGmSmWk+eQPZdjHanBaC8vh7aKjo6\n"
  56                 "q9FdT1DKjrRi23QyDco3f3E7hvM93IAAhw1ikNu8DT19JAxtdeMh5WAZAoGBAOdw\n"
  57                 "6neEvIFXh3RWEv2/GKVhVR8mxDqxmuFdXpOF+YWsK0Tg4uC8jm9kUGnwXgT2Mjke\n"
  58                 "oAwYAFcRbHQQGsxy/vkV16kv4aurTE2hMpjeXCAakwV0Pi2w1f9WnDokjgORkOmc\n"
  59                 "+QK9I8egdFPMVDfQjhLslhSUY0Eb4qcJ6q9WxfQzAoGBANSsAFybk+7oWAO3TtQW\n"
  60                 "YXOk1vIgcYAyS/0mEKixGZS/QdlxZbf/5b17nxTO8rvX416fIftG2ixgQ7vR6us0\n"
  61                 "m9+jq56ZFj9zP4eHJudf9h9yNo5TgwVXnMCGh/4iGbcMJgrrsfxUHu5VNiK5UCSj\n"
  62                 "VtqAZGDoZVryUMIkXQVhezIRAoGBAN7QUIqcGbcUA24257Wu4hVlrUN+WPCAyDEr\n"
  63                 "aL/x/ZV5eXaoYwQlw6LuGpTDOmDgfN2M5FyARuOL/LOIRaSLGXnIU4WoeUSCd8VM\n"
  64                 "6Z9Og7bMnrpjfPEUDBH02hcH1kkNPUwLOZgva2Dm0tdSIcpSWFVTu/E4Io4uQHi8\n"
  65                 "DVqc2ZsNAoGBAJT76ezXNSSv8hnrKqTpwgTicpqhRZ3eFQjyl4HRL26AJMKv++x8\n"
  66                 "4/IsVIwxaHzpbN3nnCjmAHV4gX9YpxVnvYcZflC9WZeDkwNMLmPYb3Zg27EzSMfQ\n"
  67                 "8yrfWJZo3qobipcHf1yohAt4fHk9kUKtPHEwp0xKe//rfhswLb3VCzvQ\n"
  68                 "-----END RSA PRIVATE KEY-----";
  69
  70         const char *public_key =
  71                 "-----BEGIN PUBLIC KEY-----\n"
  72                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0kWtjpRO7Zh2KX2naVE/\n"
  73                 "BDJdrfwK9xexfNA0MkY2VJ4J2AKMYTj1D1jntceryupCEHOvP3rum+WsFvPXduz9\n"
  74                 "+VKnSsSqj4jcTUubtpDUGA5G79IqLEPFuSBaqI8Uwkzd08pE+s30oaJDnNazMhSq\n"
  75                 "8JkqBPoCCwtUs73ruE9VbtsBO/kTlASIAfe8nXqcJLcDQgWYhizjJw0Pi6d74oCw\n"
  76                 "S2OTvQDNvsXfFnA0ZJEEYw/rZLirj7OHoOjz+Sh5N+1uA3Up6SPPEbHuP6L12Yxq\n"
  77                 "Hdy7gnJXodLhvE/cR4SN9VW7+qmCMBjmLkBejGrEX3STS9sLI7MZHu9Y26dwuYb4\n"
  78                 "+wIDAQAB\n"
  79                 "-----END PUBLIC KEY-----";
  80
  81         std::vector<unsigned char> dek(32, 0);
  82
  83         unsigned char *_encrypted = nullptr;
  84         size_t _encrypted_len = 0;
  85         int ret = encrypt_app_dek(reinterpret_cast<const unsigned char *>(public_key),
  86                                                           strlen(public_key), dek.data(), dek.size(), &_encrypted,
  87                                                           &_encrypted_len);
  88         auto encrypted = Wae::Test::bytearr_to_vec(_encrypted, _encrypted_len);
  89         free(_encrypted);
  90
  91         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to encrypt_app_dek. ec: " << ret);
  92
  93         unsigned char *_decrypted = nullptr;
  94         size_t _decrypted_len = 0;
  95         ret = decrypt_app_dek(reinterpret_cast<const unsigned char *>(private_key),
  96                                                   strlen(private_key), nullptr, encrypted.data(), encrypted.size(),
  97                                                   &_decrypted, &_decrypted_len);
  98         auto decrypted = Wae::Test::bytearr_to_vec(_decrypted, _decrypted_len);
  99         free(_decrypted);
 100
 101         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to decrypt_app_dek. ec: " << ret);
 102
 103         BOOST_REQUIRE_MESSAGE(dek == decrypted,
 104                         "encrypted/decrypted dek isn't valid. "
 105                         "dek(" << Wae::Test::bytes_to_hex(dek) << ") "
 106                         "decrypted(" << Wae::Test::bytes_to_hex(decrypted) << ")");
 107 }
 108
 109 BOOST_AUTO_TEST_CASE(encrypt_decrypt_aes_cbc)
 110 {
 111         std::vector<unsigned char> plaintext = {
 112                 'a', 'b', 'c', 'a', 'b', 'c', 'x', 'y',
 113                 'o', 'q', '2', 'e', 'v', '0', '1', 'x'
 114         };
 115
 116         size_t dek_len = 32;
 117         std::vector<unsigned char> dek(dek_len, 0);
 118
 119         int ret = _get_random(dek.size(), dek.data());
 120         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get random");
 121
 122         unsigned char *_encrypted = nullptr;
 123         size_t _encrypted_len = 0;
 124         ret = encrypt_aes_cbc(dek.data(), dek.size(), plaintext.data(), plaintext.size(),
 125                                                   &_encrypted, &_encrypted_len);
 126         auto encrypted = Wae::Test::bytearr_to_vec(_encrypted, _encrypted_len);
 127         free(_encrypted);
 128
 129         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to encrypt_aes_cbc. ec: " << ret);
 130
 131         unsigned char *_decrypted = nullptr;
 132         size_t _decrypted_len = 0;
 133         ret = decrypt_aes_cbc(dek.data(), dek.size(), encrypted.data(), encrypted.size(),
 134                                                   &_decrypted, &_decrypted_len);
 135         auto decrypted = Wae::Test::bytearr_to_vec(_decrypted, _decrypted_len);
 136         free(_decrypted);
 137
 138         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to decrypt_aes_cbc. ec: " << ret);
 139         BOOST_REQUIRE_MESSAGE(plaintext == decrypted,
 140                         "decrypted plaintext isn't valid. "
 141                         "plaintext(" << Wae::Test::bytes_to_hex(plaintext) << ") "
 142                         "decrypted(" << Wae::Test::bytes_to_hex(decrypted) << ")");
 143 }
 144
 145 BOOST_AUTO_TEST_CASE(cache)
 146 {
 147         const char *pkg1 = "pkg1";
 148         const char *pkg2 = "pkg2";
 149         const char *pkg3 = "pkg3";
 150         const char *pkgDummy = "dummy";
 151
 152         std::vector<unsigned char> dek1(32, 1);
 153         std::vector<unsigned char> dek2(32, 2);
 154         std::vector<unsigned char> dek3(32, 3);
 155
 156         _initialize_cache();
 157
 158         _add_app_dek_to_cache(pkg1, dek1.data());
 159         _add_app_dek_to_cache(pkg2, dek2.data());
 160         _add_app_dek_to_cache(pkg3, dek3.data());
 161
 162         size_t dek_len = 32;
 163         const unsigned char *_cached = _get_app_dek_from_cache(pkg1);
 164         auto cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 165
 166         BOOST_REQUIRE_MESSAGE(cached == dek1,
 167                         "cached dek isn't valid! "
 168                         "dek(" << Wae::Test::bytes_to_hex(dek1) << ") "
 169                         "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
 170
 171         _cached = _get_app_dek_from_cache(pkg2);
 172         cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 173
 174         BOOST_REQUIRE_MESSAGE(cached == dek2,
 175                         "cached dek isn't valid! "
 176                         "dek(" << Wae::Test::bytes_to_hex(dek2) << ") "
 177                         "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
 178
 179         _cached = _get_app_dek_from_cache(pkg3);
 180         cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 181
 182         BOOST_REQUIRE_MESSAGE(cached == dek3,
 183                         "cached dek isn't valid! "
 184                         "dek(" << Wae::Test::bytes_to_hex(dek3) << ") "
 185                         "cached(" << Wae::Test::bytes_to_hex(cached) << ")");
 186
 187         _cached = _get_app_dek_from_cache(pkgDummy);
 188         if (_cached) {
 189                 cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 190                 BOOST_REQUIRE_MESSAGE(false,
 191                                 "wrong cached val is extracted by dummy pkg id. "
 192                                 "val(" << Wae::Test::bytes_to_hex(cached) << ")");
 193         }
 194
 195         _remove_app_dek_from_cache(pkg3);
 196
 197         _cached = _get_app_dek_from_cache(pkg3);
 198         if (_cached) {
 199                 cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 200                 BOOST_REQUIRE_MESSAGE(false,
 201                                 "app dek removed from cache but it's remained! "
 202                                 "val(" << Wae::Test::bytes_to_hex(cached) << ")");
 203         }
 204
 205         _initialize_cache();
 206
 207         _add_app_dek_to_cache(pkg1, dek1.data());
 208
 209         _cached = nullptr;
 210         _cached = _get_app_dek_from_cache(pkg2);
 211         if (_cached) {
 212                 cached = Wae::Test::bytearr_to_vec(_cached, dek_len);
 213                 BOOST_REQUIRE_MESSAGE(false,
 214                                 "cache is initialized but something is remained! "
 215                                 "val(" << Wae::Test::bytes_to_hex(cached) << ")");
 216         }
 217 }
 218
 219 BOOST_AUTO_TEST_CASE(read_write_encrypted_app_dek)
 220 {
 221         const char *pkg_id = "write_test_pkg";
 222
 223         std::vector<unsigned char> dek(256, 0);
 224
 225         int ret = _write_encrypted_app_dek_to_file(pkg_id, dek.data(), dek.size());
 226         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to write_encrypted_app_dek_to_file. ec: " << ret);
 227
 228         unsigned char *_readed = nullptr;
 229         size_t _readed_len = 0;
 230         ret = _read_encrypted_app_dek_from_file(pkg_id, &_readed, &_readed_len);
 231         auto readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
 232         free(_readed);
 233         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to read_encrypted_app_dek_from_file. ec: " << ret);
 234
 235         BOOST_REQUIRE_MESSAGE(dek == readed,
 236                         "dek isn't match after write/read file. "
 237                         "dek(" << Wae::Test::bytes_to_hex(dek) << ") "
 238                         "readed(" << Wae::Test::bytes_to_hex(readed) << ")");
 239 }
 240
 241 BOOST_AUTO_TEST_CASE(get_create_preloaded_app_dek_1)
 242 {
 243         const char *pkg_id = "TEST_PKG_ID_FOR_CREATE";
 244
 245         unsigned char *_readed = nullptr;
 246         size_t _readed_len = 0;
 247         int ret = get_preloaded_app_dek(pkg_id, &_readed, &_readed_len);
 248         auto readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
 249         free(_readed);
 250
 251         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NO_KEY,
 252                         "preloaded app dek to create is already exist. ec: " << ret);
 253
 254         unsigned char *_dek = nullptr;
 255         size_t _dek_len = 0;
 256         ret = create_preloaded_app_dek(pkg_id, &_dek, &_dek_len);
 257         auto dek = Wae::Test::bytearr_to_vec(_dek, _dek_len);
 258
 259         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 260                         "Failed to create_preloaded_app_dek. ec: " << ret);
 261
 262         _readed = nullptr;
 263         ret = get_preloaded_app_dek(pkg_id, &_readed, &_readed_len);
 264         readed = Wae::Test::bytearr_to_vec(_readed, _readed_len);
 265         free(_readed);
 266
 267         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 268                         "Failed to get_preloaded_app_dek. ec: " << ret);
 269
 270         BOOST_REQUIRE_MESSAGE(dek == readed,
 271                         "created/loaded dek is not matched! "
 272                         "created(" << Wae::Test::bytes_to_hex(dek) << ") "
 273                         "loaded(" << Wae::Test::bytes_to_hex(readed) << ")");
 274 }
 275
 276 BOOST_AUTO_TEST_CASE(get_create_preloaded_app_dek_2)
 277 {
 278         const char *pkg_id1 = "TEST_PKGID_1";
 279         const char *pkg_id2 = "TEST_PKGID_2";
 280
 281         char path1[MAX_PATH_LEN] = {0, };
 282         char path2[MAX_PATH_LEN] = {0, };
 283         _get_preloaded_app_dek_file_path(pkg_id1, sizeof(path1), path1);
 284         _get_preloaded_app_dek_file_path(pkg_id2, sizeof(path2), path2);
 285
 286         // remove old test data
 287         remove_app_dek(pkg_id1, WAE_PRELOADED_APP);
 288         remove_app_dek(pkg_id2, WAE_PRELOADED_APP);
 289         unlink(path1);
 290         unlink(path2);
 291
 292         // create 2 deks for preloaded app
 293         unsigned char *_dek1 = nullptr;
 294         size_t _dek_len1 = 0;
 295         int ret = create_preloaded_app_dek(pkg_id1, &_dek1, &_dek_len1);
 296         auto dek1 = Wae::Test::bytearr_to_vec(_dek1, _dek_len1);
 297         free(_dek1);
 298
 299         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 300                         "Failed to create_preloaded_app_dek. ec: " << ret);
 301
 302         unsigned char *_dek2 = nullptr;
 303         size_t _dek_len2 = 0;
 304         ret = create_preloaded_app_dek(pkg_id2, &_dek2, &_dek_len2);
 305         auto dek2 = Wae::Test::bytearr_to_vec(_dek2, _dek_len2);
 306         free(_dek2);
 307
 308         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 309                         "Failed to create_preloaded_app_dek. ec: " << ret);
 310
 311         ret = load_preloaded_app_deks(true);
 312         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 313                         "Failed to load_preloaded_app_deks. ec: " << ret);
 314
 315         unsigned char *_readed1 = nullptr;
 316         size_t _readed_len1 = 0;
 317         ret = get_app_dek(pkg_id1, WAE_PRELOADED_APP, &_readed1, &_readed_len1);
 318         auto readed1 = Wae::Test::bytearr_to_vec(_readed1, _readed_len1);
 319         free(_readed1);
 320
 321         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get_app_dek. ec: " << ret);
 322
 323         unsigned char *_readed2 = nullptr;
 324         size_t _readed_len2 = 0;
 325         ret = get_app_dek(pkg_id2, WAE_PRELOADED_APP, &_readed2, &_readed_len2);
 326         auto readed2 = Wae::Test::bytearr_to_vec(_readed2, _readed_len2);
 327         free(_readed2);
 328
 329         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE, "Failed to get_app_dek. ec: " << ret);
 330
 331         BOOST_REQUIRE_MESSAGE(dek1 == readed1,
 332                         "readed dek and original isn't matched! "
 333                         "original(" << Wae::Test::bytes_to_hex(dek1) << ") "
 334                         "readed(" << Wae::Test::bytes_to_hex(readed1) << ")");
 335
 336         BOOST_REQUIRE_MESSAGE(dek2 == readed2,
 337                         "readed dek and original isn't matched! "
 338                         "original(" << Wae::Test::bytes_to_hex(dek2) << ") "
 339                         "readed(" << Wae::Test::bytes_to_hex(readed2) << ")");
 340
 341         ret = remove_app_dek(pkg_id1, WAE_PRELOADED_APP);
 342         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 343                         "Failed remove app dek after used. ec: " << ret);
 344
 345         ret = remove_app_dek(pkg_id2, WAE_PRELOADED_APP);
 346         BOOST_REQUIRE_MESSAGE(ret == WAE_ERROR_NONE,
 347                         "Failed remove app dek after used. ec: " << ret);
 348 }
 349
 350 BOOST_AUTO_TEST_SUITE_END() // INTERNALS
 351
 352 BOOST_AUTO_TEST_SUITE_END() // SYSTEM