src/security-manager-tests/test_cases_app_defined_privilege.cpp

   1 /*
   2  * Copyright (c) 2017 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 #include <functional>
  18 #include <string>
  19 #include <sys/types.h>
  20 #include <sys/un.h>
  21 #include <unistd.h>
  22
  23 #include <cynara_test_client.h>
  24 #include <dpl/test/test_runner.h>
  25 #include <sm_api.h>
  26 #include <sm_commons.h>
  27 #include <sm_request.h>
  28 #include <tests_common.h>
  29 #include <tzplatform.h>
  30 #include <app_install_helper.h>
  31 #include <scoped_installer.h>
  32
  33 RUNNER_TEST_GROUP_INIT(SECURITY_MANAGER_APP_DEFINED_PRIVILEGE)
  34
  35 using namespace SecurityManagerTest;
  36
  37 RUNNER_CHILD_TEST(app_defined_01_global_install_untrusted)
  38 {
  39     const Privilege privilege("http://tizen.org/applicationDefinedPrivilege/app_defined_01",
  40                               Privilege::UNTRUSTED);
  41     const std::string providerAppId = "app_def_01_provider_appid";
  42     const std::string consumerAppId = "app_def_01_client_appid";
  43     const std::string ownerId = "5001";
  44     const std::string session = "S0M3S3SSI0N";
  45
  46     AppInstallHelper provider(providerAppId);
  47     AppInstallHelper consumer(consumerAppId);
  48
  49     std::string consumerLabel = consumer.generateAppLabel();
  50
  51     provider.addAppDefinedPrivilege(privilege);
  52     consumer.addPrivilege(privilege);
  53
  54     ScopedInstaller req1(provider);
  55     ScopedInstaller req2(consumer);
  56
  57     CynaraTestClient::Client cynara;
  58     cynara.check(consumerLabel, session, ownerId, privilege, CYNARA_API_ACCESS_ALLOWED);
  59
  60     // uninstall provider
  61     req1.uninstallApp();
  62
  63     cynara.check(consumerLabel, session, ownerId, privilege, CYNARA_API_ACCESS_DENIED);
  64 }
  65
  66 RUNNER_CHILD_TEST(app_defined_02_global_install_licensed)
  67 {
  68     const Privilege privilege("http://tizen.org/licensedPrivilege/app_defined_02",
  69                               "/opt/data/app_defined_02/res/license");
  70     const std::string providerAppId = "app_def_02_provider_appid";
  71     const std::string consumerAppId = "app_def_02_client_appid";
  72     const std::string ownerId = "5001";
  73     const std::string session = "S0M33S3SSI0N";
  74
  75     AppInstallHelper provider(providerAppId);
  76     AppInstallHelper consumer(consumerAppId);
  77
  78     std::string consumerLabel = consumer.generateAppLabel();
  79
  80     provider.addAppDefinedPrivilege(privilege);
  81     consumer.addPrivilege(privilege);
  82
  83     ScopedInstaller req1(provider);
  84     ScopedInstaller req2(consumer);
  85
  86     CynaraTestClient::Client cynara;
  87     cynara.check(consumerLabel, session, ownerId, privilege, CYNARA_API_ACCESS_ALLOWED);
  88
  89     // uninstall provider
  90     req1.uninstallApp();
  91
  92     cynara.check(consumerLabel, session, ownerId, privilege, CYNARA_API_ACCESS_DENIED);
  93 }
  94
  95 RUNNER_CHILD_TEST(app_defined_03_database_update)
  96 {
  97     // Because of a bug in implementation during installation of
  98     // providerB privileges of providerA were deleted from cynara
  99     // database. This test should check if bug was fixed.
 100     Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_03a",
 101                          "/opt/data/app_defined_03a/res/license");
 102     Privilege privilegeB("http://tizen.org/licensedPrivilege/app_defined_03b",
 103                          "/opt/data/app_defined_03b/res/license");
 104     const std::string providerAppIdA = "app_def_03a_provider_appid";
 105     const std::string providerAppIdB = "app_def_03b_provider_appid";
 106     const std::string consumerAppId = "app_def_03_client_appid";
 107     const std::string ownerId = "5001";
 108     const std::string session = "S0M33S3SSI0N";
 109
 110     AppInstallHelper providerA(providerAppIdA);
 111     AppInstallHelper providerB(providerAppIdB);
 112     AppInstallHelper consumer(consumerAppId);
 113
 114     std::string consumerLabel = consumer.generateAppLabel();
 115
 116     providerA.addAppDefinedPrivilege(privilegeA);
 117     providerB.addAppDefinedPrivilege(privilegeB);
 118     consumer.addPrivilege(privilegeA);
 119     consumer.addPrivilege(privilegeB);
 120
 121     ScopedInstaller req1(providerA);
 122     ScopedInstaller req2(providerB);
 123     ScopedInstaller req3(consumer);
 124
 125     CynaraTestClient::Client cynara;
 126     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 127     cynara.check(consumerLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 128
 129     // uninstall providerA
 130     req1.uninstallApp();
 131
 132     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
 133     cynara.check(consumerLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 134
 135     // uninstall providerB
 136     req2.uninstallApp();
 137
 138     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
 139     cynara.check(consumerLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_DENIED);
 140 }
 141
 142 RUNNER_CHILD_TEST(app_defined_04_app_update)
 143 {
 144     const Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_04a",
 145                                "/opt/data/app_defined_04a/res/license");
 146     const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_04b",
 147                                Privilege::UNTRUSTED);
 148     const Privilege privilegeC("http://tizen.org/licensedPrivilege/app_defined_04c",
 149                                "/opt/data/app_defined_04c/res/license");
 150     const std::string providerAppId = "app_def_04_provider_appid";
 151     const std::string consumerAppId = "app_def_04_client_appid";
 152     const std::string ownerId = "5001";
 153     const std::string session = "S0M33S3SSI0N";
 154
 155     AppInstallHelper providerV1(providerAppId);
 156     AppInstallHelper providerV2(providerAppId);
 157     AppInstallHelper consumer(consumerAppId);
 158
 159     std::string consumerLabel = consumer.generateAppLabel();
 160
 161     providerV1.addAppDefinedPrivilege(privilegeA);
 162     providerV1.addAppDefinedPrivilege(privilegeB);
 163     consumer.addPrivilege(privilegeA);
 164     consumer.addPrivilege(privilegeB);
 165     consumer.addPrivilege(privilegeC);
 166
 167     ScopedInstaller req1(providerV1);
 168     ScopedInstaller req2(consumer);
 169
 170     CynaraTestClient::Client cynara;
 171     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 172     cynara.check(consumerLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 173     cynara.check(consumerLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_DENIED);
 174
 175     // update provider version, remove privilegeA, add privilegeC
 176     providerV2.addAppDefinedPrivilege(privilegeB);
 177     providerV2.addAppDefinedPrivilege(privilegeC);
 178
 179     ScopedInstaller req3(providerV2);
 180
 181     cynara.check(consumerLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
 182     cynara.check(consumerLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 183     cynara.check(consumerLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_ALLOWED);
 184 }
 185
 186 RUNNER_CHILD_TEST(app_defined_05_global_local_install)
 187 {
 188     const Privilege privilegeA("http://tizen.org/licensedPrivilege/app_defined_05a",
 189                                Privilege::UNTRUSTED);
 190     const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_05b",
 191                                "/opt/data/app_defined_05b/res/license");
 192     const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_05c",
 193                                Privilege::UNTRUSTED);
 194     const std::string providerAppId = "app_def_05_provider_appid";
 195     const std::string consumerAppId = "app_def_05_client_appid";
 196     const std::string ownerId = "5001";
 197     const std::string bobId = "5002";
 198     const std::string session = "S0M33S3SSI0N";
 199
 200     AppInstallHelper providerGlobal(providerAppId);
 201     AppInstallHelper providerLocal(providerAppId, 5002);
 202     AppInstallHelper consumerGlobal(consumerAppId);
 203     AppInstallHelper consumerLocal(consumerAppId, 5002);
 204
 205     std::string consumerGlobalLabel = consumerGlobal.generateAppLabel();
 206     std::string consumerLocalLabel = consumerLocal.generateAppLabel();
 207
 208     providerGlobal.addAppDefinedPrivilege(privilegeA);
 209     providerGlobal.addAppDefinedPrivilege(privilegeC);
 210     providerLocal.addAppDefinedPrivilege(privilegeA);
 211     providerLocal.addAppDefinedPrivilege(privilegeB);
 212
 213     consumerGlobal.addPrivilege(privilegeA);
 214     consumerGlobal.addPrivilege(privilegeB);
 215     consumerGlobal.addPrivilege(privilegeC);
 216
 217     consumerLocal.addPrivilege(privilegeB);
 218     consumerLocal.addPrivilege(privilegeC);
 219
 220     CynaraTestClient::Client cynara;
 221
 222     // local provider only and global consumer only
 223     ScopedInstaller req1(providerLocal);
 224     ScopedInstaller req2(consumerGlobal);
 225     cynara.check(consumerGlobalLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_DENIED);
 226     cynara.check(consumerGlobalLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_DENIED);
 227     cynara.check(consumerGlobalLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_DENIED);
 228     cynara.check(consumerGlobalLabel, session, bobId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 229     cynara.check(consumerGlobalLabel, session, bobId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 230     cynara.check(consumerGlobalLabel, session, bobId, privilegeC, CYNARA_API_ACCESS_DENIED);
 231
 232     // local provider only and global/local consumer
 233     ScopedInstaller req3(consumerLocal);
 234     cynara.check(consumerLocalLabel, session, bobId, privilegeA, CYNARA_API_ACCESS_DENIED);
 235     cynara.check(consumerLocalLabel, session, bobId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 236     cynara.check(consumerLocalLabel, session, bobId, privilegeC, CYNARA_API_ACCESS_DENIED);
 237
 238     // global/local provider and global/local consumer
 239     ScopedInstaller req4(providerGlobal);
 240     cynara.check(consumerGlobalLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 241     cynara.check(consumerGlobalLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_DENIED);
 242     cynara.check(consumerGlobalLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_ALLOWED);
 243     cynara.check(consumerLocalLabel, session, bobId, privilegeA, CYNARA_API_ACCESS_DENIED);
 244     cynara.check(consumerLocalLabel, session, bobId, privilegeB, CYNARA_API_ACCESS_ALLOWED);
 245     //cynara.check(consumerLocalLabel, session, bobId, privilegeC, CYNARA_API_ACCESS_DENIED);
 246
 247     // global provider only and global/local consumer
 248     req1.uninstallApp();
 249     cynara.check(consumerGlobalLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 250     cynara.check(consumerGlobalLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_DENIED);
 251     cynara.check(consumerGlobalLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_ALLOWED);
 252     cynara.check(consumerLocalLabel, session, bobId, privilegeA, CYNARA_API_ACCESS_DENIED);
 253     cynara.check(consumerLocalLabel, session, bobId, privilegeB, CYNARA_API_ACCESS_DENIED);
 254     cynara.check(consumerLocalLabel, session, bobId, privilegeC, CYNARA_API_ACCESS_ALLOWED);
 255
 256     // global provider only and global consumer only
 257     req3.uninstallApp();
 258     cynara.check(consumerGlobalLabel, session, ownerId, privilegeA, CYNARA_API_ACCESS_ALLOWED);
 259     cynara.check(consumerGlobalLabel, session, ownerId, privilegeB, CYNARA_API_ACCESS_DENIED);
 260     cynara.check(consumerGlobalLabel, session, ownerId, privilegeC, CYNARA_API_ACCESS_ALLOWED);
 261 }
 262
 263 RUNNER_CHILD_TEST(app_defined_06_get_provider)
 264 {
 265     int result;
 266     char *pkgId = nullptr;
 267     char *appId = nullptr;
 268     const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_06a",
 269                                Privilege::UNTRUSTED);
 270     const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_06b",
 271                                Privilege::UNTRUSTED);
 272     const std::string providerId = "app_def_06_provider";
 273     uid_t uid = 5001;
 274
 275     AppInstallHelper providerGlobal(providerId);
 276     AppInstallHelper providerLocal(providerId, uid);
 277     providerGlobal.addAppDefinedPrivilege(privilegeB);
 278     providerLocal.addAppDefinedPrivilege(privilegeA);
 279     ScopedInstaller req1(providerGlobal);
 280     ScopedInstaller req2(providerLocal);
 281
 282     result = security_manager_get_app_defined_privilege_provider("noExistingPrivilege",
 283                                                                  uid, &pkgId, &appId);
 284     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 285     RUNNER_ASSERT(appId == nullptr);
 286     RUNNER_ASSERT(pkgId == nullptr);
 287
 288     result = security_manager_get_app_defined_privilege_provider(privilegeA,
 289                                                                  uid+1, &pkgId, &appId);
 290     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 291     RUNNER_ASSERT(appId == nullptr);
 292     RUNNER_ASSERT(pkgId == nullptr);
 293
 294     result = security_manager_get_app_defined_privilege_provider(privilegeA,
 295                                                                  uid, nullptr, nullptr);
 296     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 297
 298     result = security_manager_get_app_defined_privilege_provider(privilegeA,
 299                                                                  uid, &pkgId, nullptr);
 300     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
 301     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerLocal.getPkgId());
 302     free(pkgId);
 303     pkgId = nullptr;
 304
 305     result = security_manager_get_app_defined_privilege_provider(privilegeA,
 306                                                                  uid, nullptr, &appId);
 307     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
 308     RUNNER_ASSERT(appId && std::string(appId) == providerLocal.getAppId());
 309     free(appId);
 310     appId = nullptr;
 311
 312     result = security_manager_get_app_defined_privilege_provider(privilegeA,
 313                                                                  uid, &pkgId, &appId);
 314     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
 315     RUNNER_ASSERT(appId && std::string(appId) == providerLocal.getAppId());
 316     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerLocal.getPkgId());
 317     free(appId);
 318     free(pkgId);
 319     appId = nullptr;
 320     pkgId = nullptr;
 321
 322     result = security_manager_get_app_defined_privilege_provider(privilegeB,
 323                                                                  uid, &pkgId, &appId);
 324     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider failed");
 325     RUNNER_ASSERT(appId && std::string(appId) == providerGlobal.getAppId());
 326     RUNNER_ASSERT(pkgId && std::string(pkgId) == providerGlobal.getPkgId());
 327     free(appId);
 328     free(pkgId);
 329     appId = nullptr;
 330     pkgId = nullptr;
 331 }
 332
 333 RUNNER_CHILD_TEST(app_defined_07_get_provider_license)
 334 {
 335     int result;
 336     char *license = nullptr;
 337     const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_07a",
 338                                "/opt/data/app_defined_07a/res/license");
 339     const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_07b",
 340                                "/opt/data/app_defined_07b/res/license");
 341     const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_07c",
 342                                "/opt/data/app_defined_07c/res/license");
 343     const Privilege privilegeCuntrusted(privilegeC.getName(), Privilege::UNTRUSTED);
 344     const std::string providerId = "app_def_07_provider";
 345     uid_t uid = 5001;
 346
 347     AppInstallHelper providerGlobal(providerId);
 348     AppInstallHelper providerLocal(providerId, uid);
 349     providerGlobal.addAppDefinedPrivilege(privilegeB);
 350     providerGlobal.addAppDefinedPrivilege(privilegeC);
 351     providerLocal.addAppDefinedPrivilege(privilegeA);
 352     providerLocal.addAppDefinedPrivilege(privilegeCuntrusted);
 353
 354     ScopedInstaller req1(providerGlobal);
 355     ScopedInstaller req2(providerLocal);
 356
 357     result = security_manager_get_app_defined_privilege_license(nullptr, uid, &license);
 358     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 359     RUNNER_ASSERT(license == nullptr);
 360
 361     result = security_manager_get_app_defined_privilege_license(privilegeA, uid, nullptr);
 362     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 363
 364     result = security_manager_get_app_defined_privilege_license("noExistingPrivilege", uid, &license);
 365     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 366     RUNNER_ASSERT(license == nullptr);
 367
 368     result = security_manager_get_app_defined_privilege_license(privilegeC, uid, &license);
 369     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 370     RUNNER_ASSERT(license == nullptr);
 371
 372     result = security_manager_get_app_defined_privilege_license(privilegeA, uid+1, &license);
 373     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 374     RUNNER_ASSERT(license == nullptr);
 375
 376     result = security_manager_get_app_defined_privilege_license(privilegeB, uid, &license);
 377     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
 378     RUNNER_ASSERT(license && privilegeB.getLicense() == license);
 379     free(license);
 380     license = nullptr;
 381
 382     result = security_manager_get_app_defined_privilege_license(privilegeA, uid, &license);
 383     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
 384     RUNNER_ASSERT(license && privilegeA.getLicense() == license);
 385     free(license);
 386     license = nullptr;
 387
 388     req2.uninstallApp();
 389     result = security_manager_get_app_defined_privilege_license(privilegeC, uid, &license);
 390     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege provider license failed");
 391     RUNNER_ASSERT(license && privilegeC.getLicense() == license);
 392     free(license);
 393     license = nullptr;
 394 }
 395
 396 RUNNER_CHILD_TEST(app_defined_08_add_get_client_license)
 397 {
 398     int result;
 399     char *license = nullptr;
 400
 401     const Privilege privilegeA("http://tizen.org/applicationDefinedPrivilege/app_defined_08a",
 402                                "/opt/data/app_defined_08a/res/license");
 403     const Privilege privilegeB("http://tizen.org/applicationDefinedPrivilege/app_defined_08b",
 404                                "/opt/data/app_defined_08b/res/license");
 405     const Privilege privilegeC("http://tizen.org/applicationDefinedPrivilege/app_defined_08c",
 406                                "/opt/data/app_defined_08c/res/license");
 407     const Privilege privilegeCunset(privilegeC.getName(), Privilege::UNTRUSTED);
 408
 409     const std::string clientId = "app_def_08_client";
 410     uid_t uid = 5001;
 411
 412     AppInstallHelper clientGlobal(clientId);
 413     AppInstallHelper clientLocal(clientId, uid);
 414     clientGlobal.addPrivilege(privilegeB);
 415     clientGlobal.addPrivilege(privilegeC);
 416     clientLocal.addPrivilege(privilegeA);
 417     clientLocal.addPrivilege(privilegeCunset);
 418     ScopedInstaller req1(clientGlobal);
 419     ScopedInstaller req2(clientLocal);
 420
 421     result = security_manager_get_client_privilege_license(nullptr,
 422                                                            clientLocal.getAppId().c_str(),
 423                                                            uid, &license);
 424     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 425     RUNNER_ASSERT(license == nullptr);
 426
 427     result = security_manager_get_client_privilege_license(privilegeA, nullptr,
 428                                                            uid, &license);
 429     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 430     RUNNER_ASSERT(license == nullptr);
 431
 432     result = security_manager_get_client_privilege_license(privilegeA,
 433                                                            clientLocal.getAppId().c_str(),
 434                                                            uid, nullptr);
 435     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_INPUT_PARAM);
 436
 437     result = security_manager_get_client_privilege_license("noExistingPrivilege",
 438                                                            clientLocal.getAppId().c_str(),
 439                                                            uid, &license);
 440     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 441     RUNNER_ASSERT(license == nullptr);
 442
 443     result = security_manager_get_client_privilege_license(privilegeA, "noExistingApp",
 444                                                            uid, &license);
 445     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 446     RUNNER_ASSERT(license == nullptr);
 447
 448     result = security_manager_get_client_privilege_license(privilegeC,
 449                                                            clientLocal.getAppId().c_str(),
 450                                                            uid, &license);
 451     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 452     RUNNER_ASSERT(license == nullptr);
 453
 454     result = security_manager_get_client_privilege_license(privilegeA,
 455                                                            clientLocal.getAppId().c_str(),
 456                                                            uid+1, &license);
 457     RUNNER_ASSERT(result == SECURITY_MANAGER_ERROR_NO_SUCH_OBJECT);
 458     RUNNER_ASSERT(license == nullptr);
 459
 460     result = security_manager_get_client_privilege_license(privilegeA,
 461                                                            clientLocal.getAppId().c_str(),
 462                                                            uid, &license);
 463     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege license failed");
 464     RUNNER_ASSERT(license && privilegeA.getLicense() == license);
 465     free(license);
 466     license = nullptr;
 467
 468     req2.uninstallApp();
 469     result = security_manager_get_client_privilege_license(privilegeB,
 470                                                            clientGlobal.getAppId().c_str(),
 471                                                            uid, &license);
 472     RUNNER_ASSERT_MSG(result == SECURITY_MANAGER_SUCCESS, "getting privilege license failed");
 473     RUNNER_ASSERT(license && privilegeB.getLicense() == license);
 474     free(license);
 475     license = nullptr;
 476 }
 477
 478 RUNNER_CHILD_TEST(app_defined_09_check_system_privileges)
 479 {
 480     const std::string providerId = "app_def_09_provider";
 481     const Privilege privilege("http://tizen.org/privilege/internet", Privilege::UNTRUSTED);
 482
 483     InstallRequest requestInst;
 484     requestInst.setAppId(providerId);
 485     requestInst.setPkgId(providerId);
 486     requestInst.addAppDefinedPrivilege(privilege);
 487     Api::install(requestInst, SECURITY_MANAGER_ERROR_INPUT_PARAM);
 488     Api::uninstall(requestInst);
 489 }