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