src/ckm/ckm-common.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2014 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       ckm-common.cpp
  18  * @author     Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
  19  * @version    1.0
  20  */
  21 #include <string>
  22 #include <fstream>
  23 #include <sys/smack.h>
  24 #include <ckmc/ckmc-type.h>
  25 #include <ckm-common.h>
  26 #include <tests_common.h>
  27 #include <access_provider2.h>
  28 #include <ckm/ckm-control.h>
  29 #include <ckm/ckm-manager.h>
  30 #include <ckmc/ckmc-control.h>
  31 #include <ckmc/ckmc-manager.h>
  32 #include <service_manager.h>
  33 #include <fcntl.h>
  34 #include <unistd.h>
  35
  36 const std::string SMACK_USER_APP_PREFIX = "User::App::";
  37
  38 void generate_random(size_t random_bytes, char *output)
  39 {
  40     RUNNER_ASSERT(random_bytes>0 && output);
  41
  42     std::ifstream is("/dev/urandom", std::ifstream::binary);
  43     RUNNER_ASSERT_MSG(is, "Failed to read /dev/urandom");
  44     is.read(output, random_bytes);
  45     if(static_cast<std::streamsize>(random_bytes) != is.gcount()) {
  46         RUNNER_ASSERT_MSG(false,
  47                           "Not enough bytes read from /dev/urandom: " << random_bytes << "!=" <<
  48                           is.gcount());
  49     }
  50 }
  51
  52 const char* SERVICE[] = {
  53         "central-key-manager-listener.service",
  54         "central-key-manager.service" };
  55
  56 void start_service(ServiceIdx idx)
  57 {
  58     ServiceManager sm(SERVICE[idx]);
  59     sm.startService();
  60 }
  61
  62 void stop_service(ServiceIdx idx)
  63 {
  64     ServiceManager sm(SERVICE[idx]);
  65     sm.stopService();
  66 }
  67
  68 std::string getLabel() {
  69     int ret;
  70     char* myLabel = NULL;
  71     RUNNER_ASSERT_MSG(0 <= (ret = smack_new_label_from_self(&myLabel)),
  72                          "Failed to get smack label for self. Error: " << ret);
  73     RUNNER_ASSERT_MSG(myLabel, "NULL smack label");
  74     std::string result = myLabel;
  75     free(myLabel);
  76     return result;
  77 }
  78
  79 std::string getOwnerIdFromSelf() {
  80     const std::string& prefix = SMACK_USER_APP_PREFIX;
  81     std::string smack = getLabel();
  82     if (0 == smack.compare(0, prefix.size(), prefix))
  83         return smack.substr(prefix.size(), std::string::npos);
  84     return "/" + smack;
  85 }
  86
  87 std::string aliasWithLabel(const char *label, const char *alias)
  88 {
  89     if(label)
  90     {
  91         std::stringstream ss;
  92         ss << label << std::string(ckmc_label_name_separator) << alias;
  93         return ss.str();
  94     }
  95     return std::string(alias);
  96 }
  97
  98 // changes process label
  99 void change_label(const char* label)
 100 {
 101     int ret = smack_set_label_for_self(label);
 102     RUNNER_ASSERT_MSG(0 == ret, "Error in smack_set_label_for_self("<<label<<"). Error: " << ret);
 103 }
 104
 105 ScopedLabel::ScopedLabel(const char* label) : m_original_label(getLabel())
 106 {
 107     change_label(label);
 108 }
 109
 110 ScopedLabel::~ScopedLabel()
 111 {
 112     /*
 113      * Let it throw. If we can't restore label then remaining tests results will be
 114      * unreliable anyway.
 115      */
 116     change_label(m_original_label.c_str());
 117 }
 118
 119 const char * CKMCErrorToString(int error) {
 120 #define ERRORDESCRIBE(name) case name: return #name
 121     switch(error) {
 122         ERRORDESCRIBE(CKMC_ERROR_NONE);
 123         ERRORDESCRIBE(CKMC_ERROR_INVALID_PARAMETER);
 124         ERRORDESCRIBE(CKMC_ERROR_OUT_OF_MEMORY);
 125         ERRORDESCRIBE(CKMC_ERROR_PERMISSION_DENIED);
 126         ERRORDESCRIBE(CKMC_ERROR_SOCKET);
 127         ERRORDESCRIBE(CKMC_ERROR_BAD_REQUEST);
 128         ERRORDESCRIBE(CKMC_ERROR_BAD_RESPONSE);
 129         ERRORDESCRIBE(CKMC_ERROR_SEND_FAILED);
 130         ERRORDESCRIBE(CKMC_ERROR_RECV_FAILED);
 131         ERRORDESCRIBE(CKMC_ERROR_AUTHENTICATION_FAILED);
 132         ERRORDESCRIBE(CKMC_ERROR_BUFFER_TOO_SMALL);
 133         ERRORDESCRIBE(CKMC_ERROR_SERVER_ERROR);
 134         ERRORDESCRIBE(CKMC_ERROR_DB_LOCKED);
 135         ERRORDESCRIBE(CKMC_ERROR_DB_ERROR);
 136         ERRORDESCRIBE(CKMC_ERROR_DB_ALIAS_EXISTS);
 137         ERRORDESCRIBE(CKMC_ERROR_DB_ALIAS_UNKNOWN);
 138         ERRORDESCRIBE(CKMC_ERROR_VERIFICATION_FAILED);
 139         ERRORDESCRIBE(CKMC_ERROR_INVALID_FORMAT);
 140         ERRORDESCRIBE(CKMC_ERROR_FILE_ACCESS_DENIED);
 141         ERRORDESCRIBE(CKMC_ERROR_NOT_EXPORTABLE);
 142         ERRORDESCRIBE(CKMC_ERROR_FILE_SYSTEM);
 143         ERRORDESCRIBE(CKMC_ERROR_NOT_SUPPORTED);
 144         ERRORDESCRIBE(CKMC_ERROR_UNKNOWN);
 145         default: return "Error not defined";
 146     }
 147 #undef ERRORDESCRIBE
 148 }
 149
 150 std::string CKMCReadableError(int error) {
 151     std::string output("Error: ");
 152     output += std::to_string(error);
 153     output += " Description: ";
 154     output += CKMCErrorToString(error);
 155     return output;
 156 }
 157
 158 void save_data(const char* alias, const char *data, int expected_err)
 159 {
 160     save_data(alias, data, strlen(data), expected_err);
 161 }
 162
 163 void save_data(const char* alias, const char *data, size_t len, int expected_err = CKMC_ERROR_NONE)
 164 {
 165     RUNNER_ASSERT(alias);
 166     RUNNER_ASSERT(data);
 167
 168     ckmc_raw_buffer_s buffer;
 169     buffer.data = reinterpret_cast<unsigned char*>(const_cast<char*>(data));
 170     buffer.size = len;
 171     ckmc_policy_s policy;
 172     policy.password = NULL;
 173     policy.extractable = true;
 174
 175     int ret = ckmc_save_data(alias, buffer, policy);
 176     RUNNER_ASSERT_MSG(expected_err == ret, "Saving data failed. "
 177                         << CKMCErrorToString(ret) << " while expected: "
 178                         << CKMCErrorToString(expected_err));
 179
 180 }
 181
 182 ScopedSaveData::ScopedSaveData(const char* alias, const char *data, int expected_err) : m_alias(alias)
 183 {
 184     save_data(alias, data, expected_err);
 185 }
 186
 187 ScopedSaveData::~ScopedSaveData()
 188 {
 189     /*
 190      * Let it throw. If we can't remove data then remaining tests results will be
 191      * unreliable anyway.
 192      */
 193     check_remove_allowed(m_alias.c_str());
 194 }
 195
 196 ScopedDBUnlock::ScopedDBUnlock(uid_t user_id, const char* passwd) : m_uid(user_id)
 197 {
 198     int temp;
 199     RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(user_id, passwd)), CKMCErrorToString(temp));
 200 }
 201 ScopedDBUnlock::~ScopedDBUnlock()
 202 {
 203     int temp;
 204     RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(m_uid)), CKMCErrorToString(temp));
 205 }
 206
 207 void check_remove_allowed(const char* alias)
 208 {
 209     int ret = ckmc_remove_alias(alias);
 210     // remove, but ignore non existing
 211     RUNNER_ASSERT_MSG((CKMC_ERROR_NONE == ret) || (CKMC_ERROR_DB_ALIAS_UNKNOWN == ret),
 212                          "Removing data failed: " << CKMCErrorToString(ret));
 213 }
 214
 215 void check_remove_denied(const char* alias)
 216 {
 217     int ret = ckmc_remove_alias(alias);
 218     RUNNER_ASSERT_MSG(
 219             CKMC_ERROR_PERMISSION_DENIED == ret,
 220             "App with different label shouldn't have rights to remove this data. "
 221             << CKMCReadableError(ret));
 222 }
 223
 224 void check_remove_not_visible(const char* alias)
 225 {
 226     int ret = ckmc_remove_alias(alias);
 227     RUNNER_ASSERT_MSG(
 228             CKMC_ERROR_DB_ALIAS_UNKNOWN == ret,
 229             "App with different label shouldn't have rights to see this data. "
 230             << CKMCReadableError(ret));
 231 }
 232
 233 void check_read(const char* alias,
 234                 const char *label,
 235                 const char *test_data,
 236                 size_t len,
 237                 int expected_code)
 238 {
 239     ckmc_raw_buffer_s* buffer = NULL;
 240     int ret = ckmc_get_data(aliasWithLabel(label, alias).c_str(), NULL, &buffer);
 241     RUNNER_ASSERT_MSG(expected_code == ret, "Getting data failed. "
 242                       "Expected " << CKMCErrorToString(expected_code) << ", "
 243                       "while result " << CKMCErrorToString(ret));
 244
 245     if(expected_code == CKMC_ERROR_NONE)
 246     {
 247         // compare data with expected
 248         RUNNER_ASSERT_MSG(
 249                 buffer->size == len,
 250                 "Extracted data length do not match expected data length (encrypted?):" <<
 251                 buffer->size << "!=" << len);
 252
 253         RUNNER_ASSERT_MSG(
 254                 memcmp(const_cast<const char*>(reinterpret_cast<char*>(buffer->data)),
 255                        test_data, buffer->size) == 0,
 256                 "Extracted data do not match expected data (encrypted?).");
 257
 258         ckmc_buffer_free(buffer);
 259     }
 260 }
 261
 262 void check_read(const char* alias, const char *label, const char *test_data, int expected_code)
 263 {
 264     check_read(alias, label, test_data, strlen(test_data), expected_code);
 265 }
 266
 267 void check_read_allowed(const char* alias, const char *data)
 268 {
 269     // try to read previously saved data - label taken implicitly
 270     check_read(alias, NULL, data);
 271 }
 272
 273 void check_read_not_visible(const char* alias)
 274 {
 275     // try to read previously saved data - label taken implicitly
 276     {
 277         ckmc_raw_buffer_s* buffer = NULL;
 278         int ret = ckmc_get_data(alias, NULL, &buffer);
 279         RUNNER_ASSERT_MSG(CKMC_ERROR_DB_ALIAS_UNKNOWN == ret,
 280                             "App with different label shouldn't have rights to see this data. " << CKMCErrorToString(ret));
 281         ckmc_buffer_free(buffer);
 282     }
 283 }
 284
 285 void check_key(const char *alias, int expected_error, ckmc_key_type_e expected_type)
 286 {
 287     ckmc_key_s *test_key = NULL;
 288     int temp = ckmc_get_key(alias, 0, &test_key);
 289     RUNNER_ASSERT_MSG(
 290             expected_error == temp,
 291             "received: " << CKMCReadableError(temp) << " while expected: " << CKMCReadableError(expected_error));
 292     if(expected_type != CKMC_KEY_NONE)
 293     {
 294         RUNNER_ASSERT_MSG(
 295                 test_key->key_type == expected_type,
 296                 "received type: " << test_key->key_type << " while expected type: " << expected_type);
 297     }
 298     ckmc_key_free(test_key);
 299 }
 300 void check_key_allowed(const char *alias, ckmc_key_type_e expected_type)
 301 {
 302     check_key(alias, CKMC_ERROR_NONE, expected_type);
 303 }
 304 void check_key_not_visible(const char *alias)
 305 {
 306     check_key(alias, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 307 }
 308 void check_cert_allowed(const char *alias)
 309 {
 310     ckmc_cert_s *test_cert = NULL;
 311     int temp = ckmc_get_cert(alias, 0, &test_cert);
 312     ckmc_cert_free(test_cert);
 313     RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == temp, CKMCReadableError(temp));
 314
 315 }
 316 void check_cert_not_visible(const char *alias)
 317 {
 318     ckmc_cert_s *test_cert = NULL;
 319     int temp = ckmc_get_cert(alias, 0, &test_cert);
 320     ckmc_cert_free(test_cert);
 321     RUNNER_ASSERT_MSG(CKMC_ERROR_DB_ALIAS_UNKNOWN == temp,
 322                       "App with different label shouldn't have rights to see this cert. " << CKMCErrorToString(temp));
 323 }
 324
 325 void allow_access(const char* alias, const char* accessor, int permissionMask)
 326 {
 327     // data removal should revoke this access
 328     int ret = ckmc_set_permission(alias, accessor, permissionMask);
 329     RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == ret, "Trying to allow access returned: "
 330                         << CKMCErrorToString(ret));
 331 }
 332
 333 void allow_access_negative(const char* alias, const char* accessor, int permissionMask, int expectedCode)
 334 {
 335     // data removal should revoke this access
 336     int ret = ckmc_set_permission(alias, accessor, permissionMask);
 337     RUNNER_ASSERT_MSG(expectedCode == ret, "Trying to allow access returned "
 338                         << CKMCErrorToString(ret) << ", while expected: "
 339                         << CKMCErrorToString(expectedCode));
 340 }
 341
 342 void deny_access(const char* alias, const char* accessor)
 343 {
 344     int ret = ckmc_set_permission(alias, accessor, CKMC_PERMISSION_NONE);
 345     RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == ret, "Denying access failed. Error: "
 346                         << CKMCErrorToString(ret));
 347 }
 348
 349 void deny_access_negative(const char* alias, const char* accessor, int expectedCode)
 350 {
 351     int ret = ckmc_set_permission(alias, accessor, CKMC_PERMISSION_NONE);
 352     RUNNER_ASSERT_MSG(expectedCode == ret, "Denying access failed. "
 353                         << CKMCErrorToString(ret) << ", while expected: "
 354                         << CKMCErrorToString(expectedCode));
 355 }
 356
 357 void unlock_user_data(uid_t user_id, const char *passwd)
 358 {
 359     int ret;
 360     auto control = CKM::Control::create();
 361     RUNNER_ASSERT_MSG(CKM_API_SUCCESS == (ret = control->unlockUserKey(user_id, passwd)),
 362                       "Error=" << CKM::ErrorToString(ret));
 363 }
 364
 365 void remove_user_data(uid_t user_id)
 366 {
 367     auto control = CKM::Control::create();
 368     control->lockUserKey(user_id);
 369     control->removeUserData(user_id);
 370 }
 371
 372 void reset_user_data(uid_t user_id, const char *passwd)
 373 {
 374     remove_user_data(user_id);
 375     unlock_user_data(user_id, passwd);
 376 }
 377
 378 ckmc_raw_buffer_s prepare_message_buffer(const char * input)
 379 {
 380     ckmc_raw_buffer_s retval;
 381     retval.data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(input));
 382     retval.size = strlen(input);
 383     return retval;
 384 }
 385
 386 void check_alias_list(const CKM::AliasVector& expected)
 387 {
 388     ckmc_alias_list_s *aliasList = NULL;
 389     int ret = ckmc_get_data_alias_list(&aliasList);
 390     RUNNER_ASSERT_MSG(ret == 0, "Failed to get the list of data aliases. " << ret << " / " << CKMCErrorToString(ret));
 391
 392     CKM::AliasVector actual;
 393     ckmc_alias_list_s *plist = aliasList;
 394     while(plist)
 395     {
 396         actual.push_back(plist->alias);
 397         plist = plist->next;
 398     }
 399     ckmc_alias_list_all_free(aliasList);
 400
 401     RUNNER_ASSERT_MSG(expected == actual, "Actual list of aliases differ from expected list.");
 402 }
 403
 404 size_t count_aliases(alias_type_ type, size_t minimum_initial_element_count)
 405 {
 406     ckmc_alias_list_s *aliasList = NULL;
 407     int ec;
 408     switch(type)
 409     {
 410         case ALIAS_KEY:
 411             ec = ckmc_get_key_alias_list(&aliasList);
 412             break;
 413
 414         case ALIAS_CERT:
 415             ec = ckmc_get_cert_alias_list(&aliasList);
 416             break;
 417
 418         case ALIAS_DATA:
 419             ec = ckmc_get_data_alias_list(&aliasList);
 420             break;
 421         default:
 422             RUNNER_ASSERT_MSG(false, "Unsupported value ALIAS_KEY == " << (int)type);
 423     }
 424
 425     if(ec == CKMC_ERROR_DB_ALIAS_UNKNOWN)
 426         return 0;
 427
 428     RUNNER_ASSERT_MSG(ec == CKMC_ERROR_NONE,
 429                       "Error: alias list failed, ec: " << CKMCErrorToString(ec));
 430
 431     ckmc_alias_list_s *plist = aliasList;
 432     size_t return_count = 0;
 433     while(plist)
 434     {
 435         plist = plist->next;
 436         return_count ++;
 437     }
 438     ckmc_alias_list_all_free(aliasList);
 439
 440     RUNNER_ASSERT_MSG(
 441       return_count >= minimum_initial_element_count,
 442       "Error: alias list failed, current element count: " << return_count <<
 443       " while expected minimal count of " << minimum_initial_element_count <<
 444       " elements");
 445
 446     return return_count;
 447 }
 448
 449 std::string sharedDatabase(const CKM::Alias & alias)
 450 {
 451     return aliasWithLabel(ckmc_owner_id_system, alias.c_str());
 452 }
 453
 454 ckmc_raw_buffer_s* createRandomBufferCAPI(size_t random_bytes)
 455 {
 456     ckmc_raw_buffer_s* buffer = NULL;
 457     char* data = static_cast<char*>(malloc(random_bytes*sizeof(char)));
 458     RUNNER_ASSERT(data);
 459     generate_random(random_bytes, data);
 460     int ret = ckmc_buffer_new(reinterpret_cast<unsigned char*>(data), random_bytes, &buffer);
 461     RUNNER_ASSERT_MSG(ret == CKMC_ERROR_NONE, "Buffer creation failed: " << CKMCErrorToString(ret));
 462     return buffer;
 463 }
 464
 465 CKM::RawBuffer createRandomBuffer(size_t random_bytes)
 466 {
 467     char buffer[random_bytes];
 468     generate_random(random_bytes, buffer);
 469     return CKM::RawBuffer(buffer, buffer + random_bytes);
 470 }
 471
 472 ckmc_key_s *generate_AES_key(size_t lengthBits, const char *passwd)
 473 {
 474     ckmc_key_s *retval = reinterpret_cast<ckmc_key_s *>(malloc(sizeof(ckmc_key_s)));
 475     RUNNER_ASSERT(retval != NULL);
 476
 477     RUNNER_ASSERT(lengthBits%8 == 0);
 478     char *char_key_AES = reinterpret_cast<char*>(malloc(lengthBits/8));
 479     RUNNER_ASSERT(char_key_AES != NULL);
 480     generate_random(lengthBits/8, char_key_AES);
 481
 482     retval->raw_key  = reinterpret_cast<unsigned char *>(char_key_AES);
 483     retval->key_size = lengthBits/8;
 484     retval->key_type = CKMC_KEY_AES;
 485     retval->password = passwd?strdup(passwd):NULL;
 486
 487     return retval;
 488 }
 489
 490 void validate_AES_key(ckmc_key_s *analyzed)
 491 {
 492     RUNNER_ASSERT_MSG(analyzed, "provided key is NULL");
 493     RUNNER_ASSERT_MSG(analyzed->raw_key != NULL, "provided key is empty");
 494     RUNNER_ASSERT_MSG(analyzed->key_size==(128/8) ||
 495                       analyzed->key_size==(192/8) ||
 496                       analyzed->key_size==(256/8), "provided key length is invalid");
 497     RUNNER_ASSERT_MSG(analyzed->key_type = CKMC_KEY_AES, "expected AES key, while got: " << analyzed->key_type);
 498 }
 499
 500 void compare_AES_keys(ckmc_key_s *first, ckmc_key_s *second)
 501 {
 502     validate_AES_key(first);
 503     validate_AES_key(second);
 504     RUNNER_ASSERT_MSG(
 505         (first->key_size==second->key_size) &&
 506         (memcmp(first->raw_key, second->raw_key, first->key_size)==0),
 507         "data has been modified in key manager");
 508     // bypassing password intentionally
 509 }
 510
 511 ParamListPtr createParamListPtr()
 512 {
 513     ckmc_param_list_h list = NULL;
 514     assert_positive(ckmc_param_list_new, &list);
 515     return ParamListPtr(list, ckmc_param_list_free);
 516 }
 517
 518 void assert_buffers_equal(const ckmc_raw_buffer_s b1, const ckmc_raw_buffer_s b2, bool equal)
 519 {
 520     if(equal) {
 521         RUNNER_ASSERT_MSG(b1.size == b2.size, "Buffer size differs: " << b1.size << "!=" << b2.size);
 522         RUNNER_ASSERT_MSG(0 == memcmp(b1.data, b2.data, b1.size), "Buffer contents differ");
 523     } else {
 524         RUNNER_ASSERT_MSG(b1.size != b2.size || 0 != memcmp(b1.data, b2.data, b1.size),
 525                           "Buffers should be different");
 526     }
 527 }
 528
 529 RawBufferPtr create_raw_buffer(ckmc_raw_buffer_s* buffer)
 530 {
 531     return RawBufferPtr(buffer, ckmc_buffer_free);
 532 }