src/ckm/privileged/system-db.cpp

   1 /*
   2  *  Copyright (c) 2000 - 2015 Samsung Electronics Co.
   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  * @file       system-db.cpp
  17  * @author     Maciej Karpiuk (m.karpiuk2@samsung.com)
  18  * @version    1.0
  19  */
  20 #include <dpl/test/test_runner.h>
  21 #include <tests_common.h>
  22 #include <ckm-common.h>
  23 #include <ckm-privileged-common.h>
  24 #include <ckm/ckm-control.h>
  25 #include <ckmc/ckmc-manager.h>
  26 #include <ckmc/ckmc-type.h>
  27 #include <access_provider2.h>
  28 #include <unistd.h>
  29 #include <sys/types.h>
  30
  31 namespace
  32 {
  33 const uid_t USER_SERVICE        = 0;
  34 const uid_t USER_SERVICE_2      = 1234;
  35 const uid_t GROUP_SERVICE_2     = 1234;
  36 const uid_t USER_SERVICE_MAX    = 4999;
  37 const uid_t GROUP_SERVICE_MAX   = 4999;
  38 const uid_t USER_SERVICE_FAIL   = 5000;
  39 const uid_t GROUP_SERVICE_FAIL  = 5000;
  40 const uid_t USER_APP            = 5050;
  41 const uid_t GROUP_APP           = 5050;
  42 const char* APP_PASS            = "user-pass";
  43
  44 const char* TEST_ALIAS          = "test-alias";
  45 const char* INVALID_LABEL       = "coco-jumbo";
  46 std::string TEST_SYSTEM_ALIAS   = sharedDatabase(TEST_ALIAS);
  47 std::string TEST_SYSTEM_ALIAS_2 = sharedDatabase("test-alias-2");
  48
  49 const char* TEST_DATA =
  50         "Lorem Ipsum. At vero eos et accusamus et iusto odio dignissimos ducimus "
  51         "qui blanditiis praesentium voluptatum deleniti atque corrupti quos dolores "
  52         "et quas molestias excepturi sint occaecati cupiditate non provident, "
  53         "similique sunt in culpa qui officia deserunt mollitia animi, id est "
  54         "laborum et dolorum fuga. ";
  55 }
  56
  57
  58 RUNNER_TEST_GROUP_INIT(T50_SYSTEM_DB);
  59
  60 RUNNER_TEST(T5010_CLIENT_APP_LOCKED_PRIVATE_DB)
  61 {
  62     RUNNER_IGNORED_MSG("This test is turn off because fix "
  63         "from tizen 2.4 that unlock db with empty password");
  64     // [prepare]
  65     // start as system service
  66     // add resource to the system DB
  67     // add permission to the resource to a user app
  68     // [test]
  69     // switch to user app, leave DB locked
  70     // try to access system DB item - expect success
  71
  72     // [prepare]
  73     remove_user_data(USER_APP);
  74     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
  75     allow_access(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_READ);
  76
  77     // [test]
  78     {
  79         ScopedAccessProvider ap(TEST_LABEL);
  80         ap.allowAPI("key-manager::api-storage", "rw");
  81         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
  82
  83         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_LOCKED);
  84     }
  85 }
  86
  87 RUNNER_TEST(T5020_CLIENT_APP_ADD_TO_PRIVATE_DB)
  88 {
  89     // [test]
  90     // switch to user app, unlock DB
  91     // when accessing private DB - owner==me
  92     // try to write to private DB - expect success
  93     // try to get item from private DB - expect success
  94
  95     // [test]
  96     {
  97         remove_user_data(USER_APP);
  98         ScopedDBUnlock unlock(USER_APP, APP_PASS);
  99         ScopedAccessProvider ap(TEST_LABEL);
 100         ap.allowAPI("key-manager::api-storage", "rw");
 101         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 102
 103         ScopedSaveData ssd(TEST_ALIAS, TEST_DATA);
 104         check_read(TEST_ALIAS, TEST_LABEL, TEST_DATA);
 105     }
 106 }
 107
 108 RUNNER_TEST(T5030_CLIENT_APP_TRY_ADDING_SYSTEM_ITEM, RemoveDataEnv<0, USER_APP>)
 109 {
 110     // [test]
 111     // switch to user app, unlock DB
 112     // try to add item to system DB  - expect fail
 113
 114     // [test]
 115     {
 116         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 117         ScopedAccessProvider ap(TEST_LABEL);
 118         ap.allowAPI("key-manager::api-storage", "rw");
 119         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 120
 121         save_data(aliasWithLabel(SYSTEM_LABEL, TEST_ALIAS).c_str(), TEST_DATA, CKMC_ERROR_PERMISSION_DENIED);
 122         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 123     }
 124 }
 125
 126 RUNNER_TEST(T5031_CLIENT_APP_ACCESS_WITH_PERMISSION, RemoveDataEnv<0, USER_APP>)
 127 {
 128     // [prepare]
 129     // start as system service
 130     // add resource to the system DB
 131     // add permission to the resource to a user app
 132     // [test]
 133     // switch to user app, unlock DB
 134     // try to access the system item - expect success
 135
 136     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 137     allow_access(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_READ);
 138
 139     // [test]
 140     {
 141         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 142         ScopedAccessProvider ap(TEST_LABEL);
 143         ap.allowAPI("key-manager::api-storage", "rw");
 144         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 145
 146         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 147     }
 148 }
 149
 150 RUNNER_TEST(T5032_CLIENT_APP_ACCESS_NO_PERMISSION, RemoveDataEnv<0, USER_APP>)
 151 {
 152     // [prepare]
 153     // start as system service
 154     // add resource to the system DB
 155     // [test]
 156     // switch to user app, unlock DB
 157     // try to access the system item - expect fail
 158
 159     // [prepare]
 160     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 161
 162     // [test]
 163     {
 164         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 165         ScopedAccessProvider ap(TEST_LABEL);
 166         ap.allowAPI("key-manager::api-storage", "rw");
 167         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 168
 169         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 170     }
 171 }
 172
 173 RUNNER_TEST(T5033_CLIENT_APP_PERMISSION_REMOVAL, RemoveDataEnv<0, USER_APP>)
 174 {
 175     // [prepare]
 176     // start as system service
 177     // add resource to the system DB
 178     // add permission to the resource to a user app
 179     // [test]
 180     // switch to user app, unlock DB
 181     // try to access the system item - expect success
 182     // [prepare2]
 183     // as system service, remove the item (expecting to remove permission)
 184     // add item again, do not add permission
 185     // [test2]
 186     // switch to user app, unlock DB
 187     // try to access the system item - expect fail
 188
 189     // [prepare]
 190     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 191     allow_access(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_READ);
 192
 193     // [test]
 194     {
 195         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 196         ScopedAccessProvider ap(TEST_LABEL);
 197         ap.allowAPI("key-manager::api-storage", "rw");
 198         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 199
 200         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 201     }
 202
 203     // [prepare2]
 204     check_remove_allowed(TEST_SYSTEM_ALIAS.c_str());
 205
 206     // [test2]
 207     {
 208         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 209         ScopedAccessProvider ap(TEST_LABEL);
 210         ap.allowAPI("key-manager::api-storage", "rw");
 211         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 212
 213         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 214     }
 215 }
 216
 217 RUNNER_TEST(T5034_CLIENT_APP_SET_READ_ACCESS, RemoveDataEnv<0, USER_APP>)
 218 {
 219     // [test]
 220     // switch to user app, unlock DB
 221     // try to write to private DB - expect success
 222     // try to write to system DB  - expect fail
 223
 224     // [test]
 225     {
 226         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 227         ScopedAccessProvider ap(TEST_LABEL);
 228         ap.allowAPI("key-manager::api-storage", "rw");
 229         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 230
 231         ScopedSaveData ssdsystem_user(TEST_ALIAS, TEST_DATA);
 232         ScopedSaveData ssdsystem_system(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA, CKMC_ERROR_PERMISSION_DENIED);
 233         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 234     }
 235 }
 236
 237 RUNNER_TEST(T5035_CLIENT_APP_TRY_REMOVING_SYSTEM_ITEM, RemoveDataEnv<0, USER_APP>)
 238 {
 239     // [prepare]
 240     // start as system service
 241     // add resource to the system DB
 242     // add permission to the resource to a user app
 243     // [test]
 244     // switch to user app, unlock DB
 245     // try to remove item from system DB  - expect fail
 246
 247     // [prepare]
 248     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 249     allow_access(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_READ);
 250
 251     // [test]
 252     {
 253         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 254         ScopedAccessProvider ap(TEST_LABEL);
 255         ap.allowAPI("key-manager::api-storage", "rw");
 256         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 257
 258         check_remove_denied(TEST_SYSTEM_ALIAS.c_str());
 259     }
 260 }
 261
 262 RUNNER_TEST(T5036_CLIENT_LIST_ACCESSIBLE_ITEMS, RemoveDataEnv<0, USER_APP>)
 263 {
 264     // [prepare]
 265     // start as system service
 266     // add data A to the system DB
 267     // add data B to the system DB
 268     // add permission to data A to a user app
 269     // [test]
 270     // system service list items - expect both items to appear
 271     // [test2]
 272     // switch to user app, unlock DB
 273     // add data as user
 274     // user lists items - expect system item A and private item
 275
 276     // [prepare]
 277     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 278     save_data(TEST_SYSTEM_ALIAS_2.c_str(), TEST_DATA);
 279     allow_access(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_READ);
 280
 281     // [test]
 282     check_alias_list({TEST_SYSTEM_ALIAS.c_str(), TEST_SYSTEM_ALIAS_2.c_str()});
 283
 284     // [test2]
 285     {
 286         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 287         ScopedAccessProvider ap(TEST_LABEL);
 288         ap.allowAPI("key-manager::api-storage", "rw");
 289         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 290         ScopedSaveData user_data(TEST_ALIAS, TEST_DATA);
 291
 292         check_alias_list({TEST_SYSTEM_ALIAS.c_str(),
 293                           aliasWithLabel(TEST_LABEL, TEST_ALIAS)});
 294     }
 295 }
 296
 297 RUNNER_TEST(T5037_CLIENT_APP_TRY_GENERATE_KEY_IN_SYSTEM_DB, RemoveDataEnv<USER_APP>)
 298 {
 299     // [test]
 300     // switch to user app, unlock DB
 301     // try to generate a key in system DB  - expect fail
 302
 303     // [test]
 304     {
 305         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 306         ScopedAccessProvider ap(TEST_LABEL);
 307         ap.allowAPI("key-manager::api-storage", "rw");
 308         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 309
 310         std::string private_key_alias = aliasWithLabel(SYSTEM_LABEL, "sys-db-priv");
 311         std::string public_key_alias = aliasWithLabel(SYSTEM_LABEL, "sys-db-pub");
 312         ckmc_policy_s policy_private_key;
 313         ckmc_policy_s policy_public_key;
 314         policy_private_key.password = NULL;
 315         policy_private_key.extractable = 1;
 316         policy_public_key.password = NULL;
 317         policy_public_key.extractable = 1;
 318         int temp;
 319         RUNNER_ASSERT_MSG(
 320                  CKMC_ERROR_PERMISSION_DENIED ==
 321                         (temp = ckmc_create_key_pair_rsa(1024,
 322                                                          private_key_alias.c_str(),
 323                                                          public_key_alias.c_str(),
 324                                                          policy_private_key,
 325                                                          policy_public_key)),
 326                  CKMCReadableError(temp));
 327     }
 328 }
 329
 330 RUNNER_TEST(T5038_CLIENT_SERVER_CREATE_VERIFY_SYSTEM_DB, RemoveDataEnv<0,USER_APP>)
 331 {
 332     // [prepare]
 333     // start as system service
 334     // generate RSA key in system DB
 335     // [test]
 336     // try to create and verify signature in system DB  - expect success
 337     // [test2]
 338     // switch to user app, unlock DB
 339     // try to create signature in system DB  - expect fail
 340
 341     // [prepare]
 342     std::string private_key_alias = aliasWithLabel(SYSTEM_LABEL, "sys-db-priv");
 343     std::string public_key_alias = aliasWithLabel(SYSTEM_LABEL, "sys-db-pub");
 344     ckmc_policy_s policy_private_key;
 345     ckmc_policy_s policy_public_key;
 346     policy_private_key.password = NULL;
 347     policy_private_key.extractable = 1;
 348     policy_public_key.password = NULL;
 349     policy_public_key.extractable = 1;
 350     int temp;
 351     RUNNER_ASSERT_MSG(
 352             CKMC_ERROR_NONE ==
 353                     (temp = ckmc_create_key_pair_rsa(1024,
 354                                                      private_key_alias.c_str(),
 355                                                      public_key_alias.c_str(),
 356                                                      policy_private_key,
 357                                                      policy_public_key)),
 358              CKMCReadableError(temp));
 359
 360     // [test]
 361     {
 362         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
 363         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
 364         ckmc_raw_buffer_s *signature;
 365         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
 366
 367         RUNNER_ASSERT_MSG(
 368                 CKMC_ERROR_NONE == (temp = ckmc_create_signature(
 369                         private_key_alias.c_str(),
 370                         NULL,
 371                         msg_buff,
 372                         hash_algo,
 373                         pad_algo,
 374                         &signature)),
 375                 CKMCReadableError(temp));
 376
 377         RUNNER_ASSERT_MSG(
 378                 CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
 379                         public_key_alias.c_str(),
 380                         NULL,
 381                         msg_buff,
 382                         *signature,
 383                         hash_algo,
 384                         pad_algo)),
 385                 CKMCReadableError(temp));
 386     }
 387
 388     // [test2]
 389     {
 390         ScopedDBUnlock unlock(USER_APP, APP_PASS);
 391         ScopedAccessProvider ap(TEST_LABEL);
 392         ap.allowAPI("key-manager::api-storage", "rw");
 393         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 394
 395         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
 396         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
 397         ckmc_raw_buffer_s *signature;
 398         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
 399
 400         RUNNER_ASSERT_MSG(
 401                 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_create_signature(
 402                         private_key_alias.c_str(),
 403                         NULL,
 404                         msg_buff,
 405                         hash_algo,
 406                         pad_algo,
 407                         &signature)),
 408                 CKMCReadableError(temp));
 409     }
 410 }
 411
 412 RUNNER_TEST(T5039_SYSTEM_APP_SET_REMOVE_ACCESS, RemoveDataEnv<0>)
 413 {
 414     // [prepare]
 415     // start as system service
 416     // add resource to the system DB
 417     // [test]
 418     // add remove permission to a user app - expect fail
 419
 420     // [prepare]
 421     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 422
 423     // [test]
 424     allow_access_negative(TEST_SYSTEM_ALIAS.c_str(), TEST_LABEL, CKMC_PERMISSION_REMOVE, CKMC_ERROR_INVALID_PARAMETER);
 425 }
 426
 427 RUNNER_TEST(T5040_SYSTEM_SVC_ACCESS_DB, RemoveDataEnv<0>)
 428 {
 429     // [prepare]
 430     // start as system service
 431     // add resource to the system DB
 432     // [test]
 433     // try to access the item - expect success
 434
 435     // [prepare]
 436     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 437
 438     // [test]
 439     check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 440 }
 441
 442 RUNNER_TEST(T5041_SYSTEM_SVC_1234_ACCESS_DB, RemoveDataEnv<0>)
 443 {
 444     // [prepare]
 445     // start as system service
 446     // add resource to the system DB
 447     // [test]
 448     // switch to another system service
 449     // try to access the item - expect success
 450
 451     // [prepare]
 452     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 453
 454     // [test]
 455     {
 456         ScopedAccessProvider ap(TEST_LABEL_2);
 457         ap.allowAPI("key-manager::api-storage", "rw");
 458         ap.applyAndSwithToUser(USER_SERVICE_2, GROUP_SERVICE_2);
 459
 460         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 461     }
 462 }
 463
 464 RUNNER_TEST(T5042_SYSTEM_SVC_1234_ADD_ITEM_TO_DB)
 465 {
 466     // [prepare]
 467     // start as system service 1234
 468     // add resource to the system DB
 469     // [test]
 470     // switch to another system service
 471     // try to access the item - expect success
 472
 473     // [prepare]
 474     {
 475         ScopedAccessProvider ap(TEST_LABEL_2);
 476         ap.allowAPI("key-manager::api-storage", "rw");
 477         ap.applyAndSwithToUser(USER_SERVICE_2, GROUP_SERVICE_2);
 478
 479         // [test]
 480         ScopedSaveData ssd(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 481         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 482     }
 483 }
 484
 485 RUNNER_TEST(T5043_SYSTEM_SVC_4999_ACCESS_DB, RemoveDataEnv<0>)
 486 {
 487     // [prepare]
 488     // start as system service
 489     // add resource to the system DB
 490     // [test]
 491     // switch to system service having uid maximum for system svcs
 492     // try to access the item - expect success
 493
 494     // [prepare]
 495     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 496
 497     // [test]
 498     {
 499         ScopedAccessProvider ap(TEST_LABEL_2);
 500         ap.allowAPI("key-manager::api-storage", "rw");
 501         ap.applyAndSwithToUser(USER_SERVICE_MAX, GROUP_SERVICE_MAX);
 502
 503         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 504     }
 505 }
 506
 507 RUNNER_TEST(T5044_SYSTEM_SVC_5000_ACCESS_DB, RemoveDataEnv<0>)
 508 {
 509     RUNNER_IGNORED_MSG("This test is turn off because fix "
 510         "from tizen 2.4 that unlock db with empty password");
 511     // [prepare]
 512     // start as system service
 513     // add resource to the system DB
 514     // [test]
 515     // switch to another, faulty system service with user-land uid==5000
 516     // try to access the item - expect fail (no system service)
 517
 518     // [prepare]
 519     save_data(TEST_SYSTEM_ALIAS.c_str(), TEST_DATA);
 520
 521     // [test]
 522     {
 523         ScopedAccessProvider ap(TEST_LABEL_2);
 524         ap.allowAPI("key-manager::api-storage", "rw");
 525         ap.applyAndSwithToUser(USER_SERVICE_FAIL, GROUP_SERVICE_FAIL);
 526
 527         check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA, CKMC_ERROR_DB_LOCKED);
 528     }
 529 }
 530
 531 RUNNER_TEST(T5045_SYSTEM_DB_ADD_WITH_INVALID_LABEL, RemoveDataEnv<0>)
 532 {
 533     // [prepare]
 534     // start as system service
 535     // [test]
 536     // try to add item to system DB using wrong label - expect fail
 537     // try to add item using explicit system label - expect success
 538
 539     // [test]
 540     save_data(aliasWithLabel(INVALID_LABEL, TEST_ALIAS).c_str(), TEST_DATA, CKMC_ERROR_INVALID_PARAMETER);
 541     check_read(TEST_ALIAS, INVALID_LABEL, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 542
 543     save_data(aliasWithLabel(SYSTEM_LABEL, TEST_ALIAS).c_str(), TEST_DATA);
 544     check_read(TEST_ALIAS, SYSTEM_LABEL, TEST_DATA);
 545 }