src/ckm/capi-testcases.cpp

   1 #include <dpl/test/test_runner.h>
   2 #include <dpl/test/test_runner_child.h>
   3
   4 #include <tests_common.h>
   5 #include <test-certs.h>
   6 #include <ckm-common.h>
   7 #include <access_provider2.h>
   8
   9 #include <ckm/ckm-manager.h>
  10 #include <ckm/ckm-control.h>
  11 #include <ckm/ckm-type.h>
  12
  13 #include <ckmc/ckmc-manager.h>
  14 #include <ckmc/ckmc-control.h>
  15 #include <ckmc/ckmc-type.h>
  16 #include <ckmc/ckmc-error.h>
  17
  18 #include <ckm-common.h>
  19
  20 #include <string>
  21 #include <fstream>
  22 #include <string.h>
  23 #include <stdio.h>
  24 #include <stddef.h>
  25 #include <stdlib.h>
  26
  27 namespace {
  28 const int USER_APP = 5000;
  29 const int GROUP_APP = 5000;
  30 const char* USER_PASS = "user-pass";
  31 const char* TEST_LABEL = "test_label";
  32 const char *const TEST_OBJECT1 = "OBJECT1";
  33 const std::string TEST_ALIAS1 = aliasWithLabel(TEST_LABEL,TEST_OBJECT1);
  34 const char* TEST_SYSTEM_ALIAS = "system-alias-1";
  35 const char* TEST_DATA = "ABCD";
  36 } // namespace anonymous
  37
  38
  39 RUNNER_TEST_GROUP_INIT (T301_CKMC_CONTROL_C_API);
  40
  41 RUNNER_TEST(T3010_Control_C_API_service_unlock_DB)
  42 {
  43         int temp;
  44
  45         RUNNER_ASSERT_MSG( CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_lock_user_key(0)),
  46                         CKMCReadableError(temp));
  47         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(0)),
  48                         CKMCReadableError(temp));
  49         RUNNER_ASSERT_MSG( CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_unlock_user_key(0, "test-pass")),
  50                         CKMCReadableError(temp));
  51
  52         RUNNER_ASSERT_MSG( CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_lock_user_key(4999)),
  53                         CKMCReadableError(temp));
  54         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(4999)),
  55                         CKMCReadableError(temp));
  56         RUNNER_ASSERT_MSG( CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_unlock_user_key(4999, "test-pass")),
  57                         CKMCReadableError(temp));
  58
  59         remove_user_data(5000);
  60         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(5000)),
  61                         CKMCReadableError(temp));
  62         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(5000)),
  63                         CKMCReadableError(temp));
  64         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(5000, "test-pass")),
  65                         CKMCReadableError(temp));
  66 }
  67
  68 RUNNER_TEST(T3011_Control_C_API)
  69 {
  70         int temp;
  71
  72         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
  73                         CKMCReadableError(temp));
  74
  75         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
  76                         CKMCReadableError(temp));
  77 }
  78
  79 RUNNER_TEST(T3012_Control_C_API)
  80 {
  81         int temp;
  82
  83         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
  84                         CKMCReadableError(temp));
  85         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
  86                         CKMCReadableError(temp));
  87 }
  88
  89 RUNNER_TEST(T3013_Control_C_API)
  90 {
  91         int temp;
  92
  93         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
  94                         CKMCReadableError(temp));
  95 }
  96
  97 RUNNER_TEST(T3014_Control_C_API)
  98 {
  99         int temp;
 100         const uid_t UNIQUE_USER = 6500;
 101
 102         // clean up environment
 103         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
 104                         CKMCReadableError(temp));
 105         // unlock with empty password
 106         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, NULL)),
 107                         CKMCReadableError(temp));
 108         // reset password (NULL, "simple-password")
 109         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
 110                         CKMCReadableError(temp));
 111         // get rid of NULL DKEK
 112         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(UNIQUE_USER, "simple-password")),
 113                         CKMCReadableError(temp));
 114         // lock db
 115         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(UNIQUE_USER)),
 116                         CKMCReadableError(temp));
 117         // try to reset password when db locked
 118         RUNNER_ASSERT_MSG( CKMC_ERROR_BAD_REQUEST == (temp = ckmc_reset_user_password(UNIQUE_USER, "simple-password")),
 119                         CKMCReadableError(temp));
 120         // clean up environment
 121         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(UNIQUE_USER)),
 122                         CKMCReadableError(temp));
 123 }
 124
 125 RUNNER_TEST(T3015_Control_C_API)
 126 {
 127         int temp;
 128
 129         RUNNER_ASSERT_MSG(
 130                         CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
 131                         CKMCReadableError(temp));
 132         RUNNER_ASSERT_MSG(
 133                         CKMC_ERROR_NONE == (temp = ckmc_change_user_password(USER_APP, "simple-password", "new-pass")),
 134                         CKMCReadableError(temp));
 135         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
 136                         CKMCReadableError(temp));
 137         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 138                         CKMCReadableError(temp));
 139 }
 140
 141 RUNNER_TEST(T3016_Control_C_API)
 142 {
 143         int temp;
 144
 145         RUNNER_ASSERT_MSG(
 146                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
 147                         CKMCReadableError(temp));
 148         RUNNER_ASSERT_MSG(
 149                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 150                         CKMCReadableError(temp));
 151 }
 152
 153 RUNNER_TEST(T3017_Control_C_API_remove_system_DB)
 154 {
 155         save_data(sharedDatabase(TEST_SYSTEM_ALIAS).c_str(), TEST_DATA);
 156
 157         // [test] - expect success
 158         check_read(TEST_SYSTEM_ALIAS, ckmc_owner_id_system, TEST_DATA);
 159
 160         // remove user data - expect to map to the system DB
 161         int temp;
 162         RUNNER_ASSERT_MSG(
 163                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(1234)),
 164                         CKMCReadableError(temp));
 165
 166         // [test] - expect fail
 167         check_read(TEST_SYSTEM_ALIAS, ckmc_owner_id_system, TEST_DATA, CKMC_ERROR_DB_ALIAS_UNKNOWN);
 168 }
 169
 170 RUNNER_TEST_GROUP_INIT (T302_CKMC_QUICK_SET_GET_TESTS_C_API);
 171
 172 RUNNER_TEST(T30201_init_C_API)
 173 {
 174         int temp;
 175
 176         remove_user_data(0);
 177         RUNNER_ASSERT_MSG(
 178                         CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
 179                         CKMCReadableError(temp));
 180 }
 181
 182 RUNNER_TEST(T30202_RSA_key_C_API)
 183 {
 184         int temp;
 185
 186         ckmc_key_s test_key, *test_key2;
 187         ckmc_policy_s test_policy;
 188
 189         char* password = NULL;
 190         CKM::Alias alias = sharedDatabase("mykey");
 191
 192         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 193                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 194                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 195                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 196                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 197                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 198                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 199                 "zQIDAQAB\n"
 200                 "-----END PUBLIC KEY-----";
 201
 202         char* char_keypem = new char[keyPem.length() + 1];
 203
 204         std::strcpy(char_keypem, keyPem.c_str());
 205         test_key.raw_key =  (unsigned char *)char_keypem;
 206         test_key.key_size = keyPem.length();
 207         test_key.key_type = CKMC_KEY_RSA_PUBLIC;
 208         test_key.password = password;
 209
 210         test_policy.password = password;
 211         test_policy.extractable = 1;
 212
 213         test_key2 = &test_key;
 214
 215         RUNNER_ASSERT_MSG(
 216                         CKMC_ERROR_NONE == (temp = ckmc_save_key(alias.c_str(), test_key, test_policy)),
 217                         CKMCReadableError(temp));
 218
 219         RUNNER_ASSERT_MSG(
 220                         CKMC_ERROR_NONE == (temp = ckmc_get_key(alias.c_str(), password, &test_key2)),
 221                         CKMCReadableError(temp));
 222 }
 223
 224 RUNNER_TEST(T30203_AES_key_C_API)
 225 {
 226         int temp;
 227         CKM::Alias alias = sharedDatabase("my_AES_key");
 228         size_t key_length = 192;
 229
 230         ckmc_key_s *test_key = generate_AES_key(key_length, NULL);
 231         ckmc_key_s *test_key2;
 232         ckmc_policy_s test_policy;
 233         test_policy.password = NULL;
 234         test_policy.extractable = 1;
 235
 236         RUNNER_ASSERT_MSG(
 237                         CKMC_ERROR_NONE == (temp = ckmc_save_key(alias.c_str(), *test_key, test_policy)),
 238                         CKMCReadableError(temp));
 239
 240         RUNNER_ASSERT_MSG(
 241                         CKMC_ERROR_NONE == (temp = ckmc_get_key(alias.c_str(), NULL, &test_key2)),
 242                         CKMCReadableError(temp));
 243
 244         compare_AES_keys(test_key, test_key2);
 245         ckmc_key_free(test_key);
 246         ckmc_key_free(test_key2);
 247 }
 248
 249 RUNNER_TEST(T30204_certificate_C_API)
 250 {
 251         int temp;
 252
 253         std::string certPem = TestData::getTestCertificateBase64(TestData::GIAG2);
 254
 255         char* password = NULL;
 256         ckmc_cert_s *cert2;
 257         ckmc_cert_s cert;
 258
 259         CKM::Alias alias = sharedDatabase("test-cert-1-RSA");
 260
 261         ckmc_policy_s test_policy;
 262         test_policy.password = password;
 263         test_policy.extractable = 1;
 264
 265         char* char_certPem = new char[certPem.length() + 1];
 266         std::strcpy(char_certPem, certPem.c_str());
 267         cert.raw_cert =  (unsigned char *)char_certPem;
 268         cert.cert_size = certPem.length();
 269         cert.data_format = CKMC_FORM_PEM;
 270
 271         RUNNER_ASSERT_MSG(
 272                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias.c_str(), cert, test_policy)),
 273                         CKMCReadableError(temp));
 274
 275         RUNNER_ASSERT_MSG(
 276                         CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias.c_str(), password, &cert2)),
 277                         CKMCReadableError(temp));
 278
 279         ckmc_cert_free(cert2);
 280 }
 281
 282 RUNNER_TEST(T30205_certificate_remove_C_API)
 283 {
 284         int temp;
 285
 286         char* password = NULL;
 287         ckmc_cert_s *cert2;
 288         CKM::Alias alias = sharedDatabase("test-cert-1-RSA");
 289
 290         RUNNER_ASSERT_MSG(
 291                         CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias.c_str(), password, &cert2)),
 292                         CKMCReadableError(temp));
 293         ckmc_cert_free(cert2);
 294
 295         RUNNER_ASSERT_MSG(
 296                         CKMC_ERROR_NONE == (temp = ckmc_remove_cert(alias.c_str())),
 297                         CKMCReadableError(temp));
 298
 299         RUNNER_ASSERT_MSG(
 300                         CKMC_ERROR_NONE != (temp = ckmc_get_cert(alias.c_str(), password, &cert2)),
 301                         CKMCReadableError(temp));
 302 }
 303
 304 RUNNER_TEST(T30206_certificate_list_C_API)
 305 {
 306         int temp;
 307
 308         std::string certPem = TestData::getTestCertificateBase64(TestData::GIAG2);
 309
 310         char* password = NULL;
 311         ckmc_cert_s cert;
 312
 313         ckmc_policy_s test_policy;
 314         test_policy.password = password;
 315         test_policy.extractable = 1;
 316
 317         char* char_certPem = new char[certPem.length() + 1];
 318         std::strcpy(char_certPem, certPem.c_str());
 319         cert.raw_cert =  (unsigned char *)char_certPem;
 320         cert.cert_size = certPem.length();
 321         cert.data_format = CKMC_FORM_PEM;
 322
 323         size_t current_aliases_num = count_aliases(ALIAS_CERT);
 324
 325         RUNNER_ASSERT_MSG(
 326                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(sharedDatabase("cert_test1").c_str(), cert, test_policy)),
 327                         CKMCReadableError(temp));
 328
 329         RUNNER_ASSERT_MSG(
 330                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(sharedDatabase("cert_test2").c_str(), cert, test_policy)),
 331                         CKMCReadableError(temp));
 332
 333         RUNNER_ASSERT_MSG(
 334                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(sharedDatabase("cert_test3").c_str(), cert, test_policy)),
 335                         CKMCReadableError(temp));
 336
 337         size_t actual_cnt = count_aliases(ALIAS_CERT);
 338         RUNNER_ASSERT_MSG(
 339                         (current_aliases_num+3) == actual_cnt,
 340                         "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << actual_cnt);
 341 }
 342
 343
 344 RUNNER_CHILD_TEST(T30207_user_app_save_RSA_key_C_API)
 345 {
 346         ScopedAccessProvider ap("mylabel");
 347         ap.allowAPI("key-manager::api-storage", "rw");
 348         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 349
 350         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 351                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 352                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 353                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 354                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 355                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 356                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 357                 "zQIDAQAB\n"
 358                 "-----END PUBLIC KEY-----";
 359
 360         int temp;
 361
 362         ckmc_key_s test_key, *test_key2;
 363         ckmc_policy_s test_policy;
 364
 365         char* password = NULL;
 366         const char *passwordPolicy = "x";
 367         const char *alias = "mykey";
 368         char* char_keypem = new char[keyPem.length() + 1];
 369
 370         std::strcpy(char_keypem, keyPem.c_str());
 371         test_key.raw_key =  (unsigned char *)char_keypem;
 372         test_key.key_size = keyPem.length();
 373         test_key.key_type = CKMC_KEY_RSA_PUBLIC;
 374         test_key.password = password;
 375
 376         test_policy.password = const_cast<char *>(passwordPolicy);
 377         test_policy.extractable = 1;
 378
 379         test_key2 = &test_key;
 380
 381
 382         RUNNER_ASSERT_MSG(
 383                         CKMC_ERROR_NONE == (temp = ckmc_save_key(alias, test_key, test_policy)),
 384                         CKMCReadableError(temp));
 385         RUNNER_ASSERT_MSG(
 386                         CKMC_ERROR_NONE == (temp = ckmc_get_key(alias, passwordPolicy, &test_key2)),
 387                         CKMCReadableError(temp));
 388
 389         //       RUNNER_ASSERT_MSG(
 390         //                       key.getDER() == key2.getDER(), "Key value has been changed by service");
 391
 392         delete [] char_keypem;
 393 }
 394
 395 RUNNER_CHILD_TEST(T30208_user_app_save_AES_key_C_API)
 396 {
 397         AccessProvider ap("mylabel");
 398         ap.allowAPI("key-manager::api-storage", "rw");
 399         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 400
 401         int temp;
 402         const char* password = NULL;
 403         size_t key_length = 192;
 404         CKM::Alias alias = "my_AES_key";
 405
 406         ckmc_key_s *test_key = generate_AES_key(key_length, password);
 407         ckmc_key_s *test_key2;
 408         ckmc_policy_s test_policy;
 409         test_policy.password = const_cast<char *>(password);
 410         test_policy.extractable = 1;
 411
 412         RUNNER_ASSERT_MSG(
 413                         CKMC_ERROR_NONE == (temp = ckmc_save_key(alias.c_str(), *test_key, test_policy)),
 414                         CKMCReadableError(temp));
 415         RUNNER_ASSERT_MSG(
 416                         CKMC_ERROR_NONE == (temp = ckmc_get_key(alias.c_str(), password, &test_key2)),
 417                         CKMCReadableError(temp));
 418
 419         compare_AES_keys(test_key, test_key2);
 420         ckmc_key_free(test_key);
 421         ckmc_key_free(test_key2);
 422 }
 423
 424 RUNNER_CHILD_TEST(T30209_user_app_save_AES_key_passwd_C_API)
 425 {
 426         AccessProvider ap("mylabel");
 427         ap.allowAPI("key-manager::api-storage", "rw");
 428         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 429
 430         int temp;
 431         const char* password = "x";
 432         size_t key_length = 192;
 433         CKM::Alias alias = "my_AES_key-2";
 434
 435         ckmc_key_s *test_key = generate_AES_key(key_length, password);
 436         ckmc_policy_s test_policy;
 437         test_policy.password = const_cast<char *>(password);
 438         test_policy.extractable = 1;
 439
 440         RUNNER_ASSERT_MSG(
 441                 CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_save_key(alias.c_str(), *test_key, test_policy)),
 442                 CKMCReadableError(temp));
 443         ckmc_key_free(test_key);
 444 }
 445
 446 RUNNER_CHILD_TEST(T30210_app_user_save_RSA_keys_exportable_flag)
 447 {
 448         ScopedAccessProvider ap("mylabel");
 449         ap.allowAPI("key-manager::api-storage", "rw");
 450         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 451
 452         int temp;
 453         auto manager = CKM::Manager::create();
 454
 455         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 456                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 457                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 458                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 459                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 460                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 461                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 462                 "zQIDAQAB\n"
 463                 "-----END PUBLIC KEY-----";
 464
 465         ckmc_policy_s test_policy;
 466         ckmc_key_s test_key, *test_key2;
 467         char* char_keypem = new char[keyPem.length() + 1];
 468         char* password = NULL;
 469
 470         std::strcpy(char_keypem, keyPem.c_str());
 471         test_key.raw_key = (unsigned char *)char_keypem;
 472         test_key.key_size = keyPem.length();
 473         test_key.key_type = CKMC_KEY_RSA_PUBLIC;
 474         test_key.password = NULL;
 475
 476         test_policy.password = password;
 477         test_policy.extractable = 0;
 478
 479         RUNNER_ASSERT_MSG(
 480                         CKMC_ERROR_NONE == (temp = ckmc_save_key("appkey1", test_key, test_policy)),
 481                         CKMCReadableError(temp));
 482
 483         RUNNER_ASSERT_MSG(
 484                         CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key("appkey1", password, &test_key2)),
 485                         CKMCReadableError(temp));
 486 }
 487
 488 RUNNER_CHILD_TEST(T30211_app_user_save_AES_keys_exportable_flag)
 489 {
 490         AccessProvider ap("mylabel");
 491         ap.allowAPI("key-manager::api-storage", "rw");
 492         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 493
 494         int temp;
 495         const char* password = NULL;
 496         size_t key_length = 256;
 497         CKM::Alias alias = "my_AES_key-3";
 498
 499         ckmc_key_s *test_key = generate_AES_key(key_length, password);
 500         ckmc_key_s *test_key2;
 501         ckmc_policy_s test_policy;
 502         test_policy.password = const_cast<char *>(password);
 503         test_policy.extractable = 0;
 504
 505         RUNNER_ASSERT_MSG(
 506                         CKMC_ERROR_NONE == (temp = ckmc_save_key(alias.c_str(), *test_key, test_policy)),
 507                         CKMCReadableError(temp));
 508         ckmc_key_free(test_key);
 509
 510         RUNNER_ASSERT_MSG(
 511                         CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key(alias.c_str(), password, &test_key2)),
 512                         CKMCReadableError(temp));
 513 }
 514
 515 RUNNER_TEST(T30212_certificate_with_DSA_key_C_API)
 516 {
 517         int temp;
 518
 519         std::string certPem = TestData::getTestCertificateBase64(TestData::GIAG2);
 520
 521         char* password = NULL;
 522         ckmc_cert_s *cert2 = NULL;
 523         ckmc_cert_s cert;
 524
 525         ckmc_policy_s test_policy;
 526         test_policy.password = password;
 527         test_policy.extractable = 1;
 528
 529         char* char_certPem = new char[certPem.length() + 1];
 530         std::strcpy(char_certPem, certPem.c_str());
 531         cert.raw_cert =  (unsigned char *)char_certPem;
 532         cert.cert_size = certPem.length();
 533         cert.data_format = CKMC_FORM_PEM;
 534
 535         CKM::Alias alias = sharedDatabase("test-cert-1-DSA");
 536         RUNNER_ASSERT_MSG(
 537                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(alias.c_str(), cert, test_policy)),
 538                         CKMCReadableError(temp));
 539
 540         RUNNER_ASSERT_MSG(
 541                         CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias.c_str(), password, &cert2)),
 542                         CKMCReadableError(temp));
 543
 544         ckmc_cert_free(cert2);
 545 }
 546
 547 RUNNER_TEST(T30213_deinit_C_API)
 548 {
 549         int temp;
 550
 551         remove_user_data(0);
 552         RUNNER_ASSERT_MSG(
 553                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
 554                         CKMCReadableError(temp));
 555         RUNNER_ASSERT_MSG(
 556                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 557                         CKMCReadableError(temp));
 558 }
 559
 560
 561 RUNNER_TEST_GROUP_INIT (T3030_CKMC_QUICK_GET_ALIAS_TESTS_C_API);
 562
 563 RUNNER_TEST(T3031_init_C_API)
 564 {
 565         int temp;
 566
 567         remove_user_data(0);
 568         RUNNER_ASSERT_MSG(
 569                         CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, "simple-password")),
 570                         CKMCReadableError(temp));
 571 }
 572
 573 RUNNER_TEST(T3032_save_asymmetric_keys_get_alias_C_API)
 574 {
 575         int temp;
 576
 577         char* password = NULL;
 578         ckmc_policy_s test_policy1, test_policy2, test_policy3;
 579         ckmc_key_s test_key;
 580
 581         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
 582                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
 583                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
 584                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
 585                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
 586                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
 587                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
 588                 "zQIDAQAB\n"
 589                 "-----END PUBLIC KEY-----";
 590
 591         char* char_keypem = new char[keyPem.length() + 1];
 592
 593         std::strcpy(char_keypem, keyPem.c_str());
 594         test_key.raw_key = (unsigned char *)char_keypem;
 595         test_key.key_size = keyPem.length();
 596         test_key.key_type = CKMC_KEY_RSA_PUBLIC;
 597         test_key.password = password;
 598
 599         test_policy1.password = password;
 600         test_policy1.extractable = 1;
 601
 602         test_policy2.password = password;
 603         test_policy2.extractable = 0;
 604
 605         test_policy3.password = password;
 606         test_policy3.extractable = 0;
 607
 608         size_t current_aliases_num = count_aliases(ALIAS_KEY);
 609
 610         RUNNER_ASSERT_MSG(
 611                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("rootkey1").c_str(), test_key, test_policy1)),
 612                         CKMCReadableError(temp));
 613
 614         RUNNER_ASSERT_MSG(
 615                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("rootkey2").c_str(), test_key, test_policy2)),
 616                         CKMCReadableError(temp));
 617
 618         RUNNER_ASSERT_MSG(
 619                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("rootkey3").c_str(), test_key, test_policy3)),
 620                         CKMCReadableError(temp));
 621
 622         size_t actual_cnt = count_aliases(ALIAS_KEY);
 623         RUNNER_ASSERT_MSG(
 624                         (current_aliases_num+3) == actual_cnt,
 625                         "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << actual_cnt);
 626 }
 627
 628
 629 RUNNER_TEST(T3033_remove_asymmetric_key_C_API)
 630 {
 631         int temp;
 632
 633         char* password = NULL;
 634
 635         ckmc_key_s *test_key2;
 636         RUNNER_ASSERT_MSG(
 637                         CKMC_ERROR_NONE == (temp = ckmc_get_key(sharedDatabase("rootkey1").c_str(), password, &test_key2)),
 638                         CKMCReadableError(temp));
 639
 640         RUNNER_ASSERT_MSG(
 641                         CKMC_ERROR_NONE == (temp = ckmc_remove_key(sharedDatabase("rootkey1").c_str())),
 642                         CKMCReadableError(temp));
 643
 644         RUNNER_ASSERT_MSG(
 645                         CKMC_ERROR_NONE != (temp = ckmc_get_key(sharedDatabase("rootkey1").c_str(), password, &test_key2)),
 646                         CKMCReadableError(temp));
 647 }
 648
 649 RUNNER_TEST(T3034_save_symmetric_keys_get_alias_C_API)
 650 {
 651         int temp;
 652         size_t key_length = 128;
 653         ckmc_key_s *test_key = generate_AES_key(key_length, NULL);
 654         ckmc_policy_s test_policy1, test_policy2, test_policy3;
 655         test_policy1.password = NULL;
 656         test_policy1.extractable = 1;
 657
 658         test_policy2.password = NULL;
 659         test_policy2.extractable = 1;
 660
 661         test_policy3.password = NULL;
 662         test_policy3.extractable = 1;
 663
 664         int current_aliases_num = count_aliases(ALIAS_KEY);
 665
 666         RUNNER_ASSERT_MSG(
 667                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("AES_key1").c_str(), *test_key, test_policy1)),
 668                         CKMCReadableError(temp));
 669
 670         RUNNER_ASSERT_MSG(
 671                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("AES_key2").c_str(), *test_key, test_policy2)),
 672                         CKMCReadableError(temp));
 673
 674         RUNNER_ASSERT_MSG(
 675                         CKMC_ERROR_NONE == (temp = ckmc_save_key(sharedDatabase("AES_key3").c_str(), *test_key, test_policy3)),
 676                         CKMCReadableError(temp));
 677
 678         RUNNER_ASSERT_MSG(
 679                         (current_aliases_num+3) == (temp = count_aliases(ALIAS_KEY)),
 680                         "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << temp);
 681
 682         ckmc_key_free(test_key);
 683 }
 684
 685
 686 RUNNER_TEST(T3035_remove_symmetric_key_C_API)
 687 {
 688         int temp;
 689
 690         ckmc_key_s *test_key2;
 691         RUNNER_ASSERT_MSG(
 692                         CKMC_ERROR_NONE == (temp = ckmc_get_key(sharedDatabase("AES_key1").c_str(), NULL, &test_key2)),
 693                         CKMCReadableError(temp));
 694         validate_AES_key(test_key2);
 695         ckmc_key_free(test_key2);
 696
 697         // actual test - remove middle item
 698         RUNNER_ASSERT_MSG(
 699                         CKMC_ERROR_NONE == (temp = ckmc_remove_key(sharedDatabase("AES_key2").c_str())),
 700                         CKMCReadableError(temp));
 701
 702         RUNNER_ASSERT_MSG(
 703                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(sharedDatabase("AES_key2").c_str(), NULL, &test_key2)),
 704                         CKMCReadableError(temp));
 705
 706         RUNNER_ASSERT_MSG(
 707                         CKMC_ERROR_NONE == (temp = ckmc_get_key(sharedDatabase("AES_key3").c_str(), NULL, &test_key2)),
 708                         CKMCReadableError(temp));
 709         validate_AES_key(test_key2);
 710         ckmc_key_free(test_key2);
 711
 712 }
 713
 714 RUNNER_TEST(T3036_deinit_C_API)
 715 {
 716         int temp;
 717
 718         remove_user_data(0);
 719         RUNNER_ASSERT_MSG(
 720                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
 721                         CKMCReadableError(temp));
 722         RUNNER_ASSERT_MSG(
 723                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 724                         CKMCReadableError(temp));
 725 }
 726
 727 RUNNER_TEST_GROUP_INIT (T3040_CKMC_QUICK_REMOVE_BIN_DATA_TEST_C_API);
 728
 729 RUNNER_TEST(T3041_init_C_API)
 730 {
 731         remove_user_data(0);
 732         reset_user_data(USER_APP, "simple-password");
 733 }
 734
 735 RUNNER_TEST(T3042_save_get_bin_data_C_API)
 736 {
 737         int temp;
 738
 739         ckmc_raw_buffer_s testData1, testData2, testData3;
 740         char* password = NULL;
 741
 742         std::string binData1 = "My bin data1";
 743         std::string binData2 = "My bin data2";
 744         std::string binData3 = "My bin data3";
 745         char* char_binData1 = new char[binData1.length() + 1];
 746         char* char_binData2 = new char[binData2.length() + 1];
 747         char* char_binData3 = new char[binData3.length() + 1];
 748         std::strcpy(char_binData1, binData1.c_str());
 749         std::strcpy(char_binData2, binData2.c_str());
 750         std::strcpy(char_binData3, binData3.c_str());
 751         testData1.data = (unsigned char *) char_binData1;
 752         testData2.data = (unsigned char *) char_binData2;
 753         testData3.data = (unsigned char *) char_binData3;
 754         testData1.size = binData1.length()+1;
 755         testData2.size = binData2.length()+1;
 756         testData3.size = binData3.length()+1;
 757
 758         ckmc_policy_s test_policy1, test_policy2, test_policy3;
 759
 760         test_policy1.password = password;
 761         test_policy1.extractable = 1;
 762         test_policy2.password = password;
 763         test_policy2.extractable = 1;
 764         test_policy3.password = password;
 765         test_policy3.extractable = 0;
 766
 767         size_t current_aliases_num = count_aliases(ALIAS_DATA);
 768
 769         RUNNER_ASSERT_MSG(
 770                         CKMC_ERROR_NONE == (temp = ckmc_save_data(sharedDatabase("data1").c_str(), testData1, test_policy1)), // should change it as null value
 771                         CKMCReadableError(temp));
 772
 773         RUNNER_ASSERT_MSG(
 774                         CKMC_ERROR_NONE == (temp = ckmc_save_data(sharedDatabase("data2").c_str(), testData2, test_policy1)), // should change it as null value
 775                         CKMCReadableError(temp));
 776
 777         RUNNER_ASSERT_MSG(
 778                         CKMC_ERROR_NONE == (temp = ckmc_save_data(sharedDatabase("data3").c_str(), testData3, test_policy2)),
 779                         CKMCReadableError(temp));
 780
 781         RUNNER_ASSERT_MSG(
 782                         CKMC_ERROR_INVALID_PARAMETER == (temp = ckmc_save_data(sharedDatabase("data4").c_str(), testData3, test_policy3)),
 783                         CKMCReadableError(temp));
 784
 785         size_t actual_cnt = count_aliases(ALIAS_DATA);
 786         RUNNER_ASSERT_MSG(
 787                         (current_aliases_num+3) == actual_cnt,
 788                         "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << actual_cnt);
 789
 790         ckmc_raw_buffer_s *testData4;
 791         RUNNER_ASSERT_MSG(
 792                         CKMC_ERROR_NONE == (temp = ckmc_get_data(sharedDatabase("data2").c_str(), password, &testData4)),
 793                         CKMCReadableError(temp));
 794
 795         int compareResult;
 796         compareResult = (strcmp((const char *)testData2.data, (const char *)testData4->data));
 797         RUNNER_ASSERT_MSG( compareResult == 0,
 798                         "Data corrupted");
 799 }
 800
 801 RUNNER_CHILD_TEST(T3043_app_user_save_bin_data_C_API)
 802 {
 803         ScopedAccessProvider ap("mylabel");
 804         ap.allowAPI("key-manager::api-storage", "rw");
 805         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 806
 807         int temp;
 808         ckmc_raw_buffer_s testData1;
 809         char* password = NULL;
 810         std::string binData1 = "My bin data";
 811         char* char_binData1 = new char[binData1.length() + 1];
 812         std::strcpy(char_binData1, binData1.c_str());
 813         testData1.data = (unsigned char *) char_binData1;
 814         testData1.size = binData1.length()+1;
 815
 816         ckmc_policy_s test_policy1, test_policy2;
 817
 818         test_policy1.password = password;
 819         test_policy1.extractable = 1;
 820
 821         test_policy2.password = password;
 822         test_policy2.extractable = 1;
 823
 824         std::string binData = "My bin data";
 825
 826         size_t current_aliases_num = count_aliases(ALIAS_DATA);
 827
 828         RUNNER_ASSERT_MSG(
 829                         CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata1", testData1, test_policy1)),
 830                         CKMCReadableError(temp));
 831         RUNNER_ASSERT_MSG(
 832                         CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata2", testData1, test_policy1)),
 833                         CKMCReadableError(temp));
 834         RUNNER_ASSERT_MSG(
 835                         CKMC_ERROR_NONE == (temp = ckmc_save_data("appdata3", testData1, test_policy2)),
 836                         CKMCReadableError(temp));
 837
 838         size_t actual_cnt = count_aliases(ALIAS_DATA);
 839         RUNNER_ASSERT_MSG(
 840                                 (current_aliases_num+3) == actual_cnt,
 841                                 "Error: expecting " << (current_aliases_num+3) << " aliases, while found " << actual_cnt);
 842 }
 843
 844 RUNNER_TEST(T3044_remove_bin_data_C_API)
 845 {
 846         int temp;
 847
 848         size_t current_aliases_num = count_aliases(ALIAS_DATA, 2);
 849
 850         RUNNER_ASSERT_MSG(
 851                         CKMC_ERROR_NONE == (temp = ckmc_remove_data(sharedDatabase("data1").c_str())),
 852                         CKMCReadableError(temp));
 853         RUNNER_ASSERT_MSG(
 854                         CKMC_ERROR_NONE == (temp = ckmc_remove_data(sharedDatabase("data3").c_str())),
 855                         CKMCReadableError(temp));
 856
 857         size_t actual_cnt = count_aliases(ALIAS_DATA);
 858         RUNNER_ASSERT_MSG(
 859                                 (current_aliases_num-2) == actual_cnt,
 860                                 "Error: expecting " << (current_aliases_num-2) << " aliases, while found " << actual_cnt);
 861
 862         char* password = NULL;
 863
 864         ckmc_raw_buffer_s *testData1, testData2;
 865
 866         std::string testStr = "My bin data2";
 867         char* char_testData2 = new char[testStr.length() + 1];
 868         std::strcpy(char_testData2, testStr.c_str());
 869         testData2.data = (unsigned char *) char_testData2;
 870         testData2.size = testStr.length()+1;
 871
 872         CKM::RawBuffer buffer;
 873         RUNNER_ASSERT_MSG(
 874                         CKMC_ERROR_NONE == (temp = ckmc_get_data(sharedDatabase("data2").c_str(), password, &testData1)),
 875                         CKMCReadableError(temp));
 876
 877         int compareResult;
 878         compareResult = (strcmp((const char *)testData2.data, (const char *)testData1->data));
 879         RUNNER_ASSERT_MSG( compareResult == 0,
 880                         "Data corrupted");
 881
 882         RUNNER_ASSERT_MSG(
 883                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_data(sharedDatabase("data3").c_str(), password, &testData1)),
 884                         CKMCReadableError(temp));
 885 }
 886
 887 RUNNER_TEST(T3045_save_big_data_C_API)
 888 {
 889         GarbageCollector gc;
 890         const size_t BIG_SIZE = 5000000; // can't go much further because of stack size limit
 891         ScopedAccessProvider ap(TEST_LABEL, USER_APP, GROUP_APP);
 892
 893         char big_data[BIG_SIZE];
 894         std::ifstream is("/dev/urandom", std::ifstream::binary);
 895         if(is)
 896                 is.read(big_data, BIG_SIZE);
 897
 898         RUNNER_ASSERT_MSG(is,
 899                         "Only " << is.gcount() << "/" << BIG_SIZE << " bytes read from /dev/urandom");
 900
 901         gc.save(TEST_ALIAS1.c_str(), big_data, BIG_SIZE, CKMC_ERROR_NONE);
 902
 903         check_read(TEST_OBJECT1, TEST_LABEL, big_data, BIG_SIZE, CKMC_ERROR_NONE);
 904 }
 905
 906 RUNNER_TEST(T3050_deinit_C_API)
 907 {
 908         int temp;
 909
 910         remove_user_data(0);
 911         RUNNER_ASSERT_MSG(
 912                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
 913                         CKMCReadableError(temp));
 914         RUNNER_ASSERT_MSG(
 915                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 916                         CKMCReadableError(temp));
 917 }
 918
 919 RUNNER_TEST_GROUP_INIT(T305_CKMC_QUICK_CREATE_PAIR_CAPI);
 920
 921 RUNNER_TEST(T3051_CAPI_init)
 922 {
 923         int temp;
 924
 925         RUNNER_ASSERT_MSG(
 926                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
 927                         CKMCReadableError(temp));
 928
 929         RUNNER_ASSERT_MSG(
 930                         CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
 931                         CKMCReadableError(temp));
 932 }
 933
 934 RUNNER_CHILD_TEST(T3052_CAPI_create_RSA_key)
 935 {
 936         int temp;
 937
 938         ScopedAccessProvider ap("mylabel");
 939         ap.allowAPI("key-manager::api-storage", "rw");
 940         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
 941
 942         size_t size = 1024;
 943         const char *private_key_alias = "RSA-test-1-priv";
 944         const char *public_key_alias = "RSA-test-1-pub";
 945         ckmc_policy_s policy_private_key;
 946         ckmc_policy_s policy_public_key;
 947
 948         policy_private_key.password = NULL;
 949         policy_private_key.extractable = 1;
 950
 951         policy_public_key.password = NULL;
 952         policy_public_key.extractable = 1;
 953
 954
 955         size_t current_aliases_num = count_aliases(ALIAS_KEY);
 956
 957         RUNNER_ASSERT_MSG(
 958                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
 959                         CKMCReadableError(temp));
 960
 961         size_t actual_cnt = count_aliases(ALIAS_KEY);
 962         RUNNER_ASSERT_MSG(
 963                         (current_aliases_num+2) == actual_cnt,
 964                         "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << actual_cnt);
 965
 966         ckmc_key_s *privateKey;
 967         RUNNER_ASSERT_MSG(
 968                         CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
 969                         CKMCReadableError(temp));
 970         RUNNER_ASSERT_MSG(
 971                         privateKey->key_type == CKMC_KEY_RSA_PRIVATE,
 972                         "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
 973         RUNNER_ASSERT_MSG(
 974                         privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
 975                         "Private key is broken.");
 976
 977         ckmc_key_s *publicKey;
 978         RUNNER_ASSERT_MSG(
 979                         CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &publicKey)),
 980                         CKMCReadableError(temp));
 981         RUNNER_ASSERT_MSG(
 982                         publicKey->key_type == CKMC_KEY_RSA_PUBLIC,
 983                         "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_RSA_PUBLIC) << ", actual=" << static_cast<int>(publicKey->key_type));
 984         RUNNER_ASSERT_MSG(
 985                         publicKey != NULL && publicKey->key_size > 0 && publicKey->raw_key != NULL,
 986                         "Public key is broken.");
 987
 988         // on next attempt to generate keys with the same alias, expect fail (alias exists)
 989         RUNNER_ASSERT_MSG(
 990                         CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
 991                         CKMCReadableError(temp));
 992 }
 993
 994 RUNNER_CHILD_TEST(T3053_CAPI_create_DSA_key)
 995 {
 996         int temp;
 997
 998         AccessProvider ap("mylabel");
 999         ap.allowAPI("key-manager::api-storage", "rw");
1000         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
1001
1002         size_t size = 1024;
1003         const char *private_key_alias = "DSA-test-2-priv";
1004         const char *public_key_alias = "DSA-test-2-pub";
1005         ckmc_policy_s policy_private_key;
1006         ckmc_policy_s policy_public_key;
1007
1008         policy_private_key.password = NULL;
1009         policy_private_key.extractable = 1;
1010
1011         policy_public_key.password = NULL;
1012         policy_public_key.extractable = 1;
1013
1014         size_t current_aliases_num = count_aliases(ALIAS_KEY);
1015
1016         RUNNER_ASSERT_MSG(
1017                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1018                         CKMCReadableError(temp));
1019
1020         size_t actual_cnt = count_aliases(ALIAS_KEY);
1021         RUNNER_ASSERT_MSG(
1022                         (current_aliases_num+2) == actual_cnt,
1023                         "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << actual_cnt);
1024
1025         ckmc_key_s *privateKey = 0;
1026         RUNNER_ASSERT_MSG(
1027                         CKMC_ERROR_NONE == (temp = ckmc_get_key(private_key_alias, policy_private_key.password,&privateKey)),
1028                         CKMCReadableError(temp));
1029         RUNNER_ASSERT_MSG(
1030                         privateKey != NULL && privateKey->key_size > 0 && privateKey->raw_key != NULL,
1031                         "Private key is broken.");
1032         RUNNER_ASSERT_MSG(
1033                         privateKey->key_type == CKMC_KEY_DSA_PRIVATE,
1034                         "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PRIVATE) << ", actual=" << static_cast<int>(privateKey->key_type));
1035         ckmc_key_free(privateKey);
1036
1037         ckmc_key_s *pubKey = 0;
1038         RUNNER_ASSERT_MSG(
1039                         CKMC_ERROR_NONE == (temp = ckmc_get_key(public_key_alias, policy_public_key.password, &pubKey)),
1040                         CKMCReadableError(temp));
1041         RUNNER_ASSERT_MSG(
1042                         pubKey != NULL && pubKey->key_size > 0 && pubKey->raw_key != NULL,
1043                         "Public key is broken.");
1044         RUNNER_ASSERT_MSG(
1045                         pubKey->key_type == CKMC_KEY_DSA_PUBLIC,
1046                         "Key Type Error: expected =" << static_cast<int>(CKMC_KEY_DSA_PUBLIC) << ", actual=" << static_cast<int>(pubKey->key_type));
1047         ckmc_key_free(pubKey);
1048
1049         // on next attempt to generate keys with the same alias, expect fail (alias exists)
1050         RUNNER_ASSERT_MSG(
1051                         CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_dsa(size, private_key_alias, public_key_alias, policy_private_key, policy_public_key)),
1052                         CKMCReadableError(temp));
1053 }
1054
1055
1056 RUNNER_CHILD_TEST(T3054_CAPI_create_AES_key)
1057 {
1058         int temp;
1059         size_t size = 128;
1060         CKM::Alias key_alias = sharedDatabase("AES-gen-test-1");
1061         ckmc_policy_s policy_key;
1062
1063         policy_key.password = NULL;
1064         policy_key.extractable = 1;
1065
1066         int current_aliases_num = count_aliases(ALIAS_KEY);
1067
1068         RUNNER_ASSERT_MSG(
1069                         CKMC_ERROR_NONE == (temp = ckmc_create_key_aes(size, key_alias.c_str(), policy_key)),
1070                         CKMCReadableError(temp));
1071
1072         RUNNER_ASSERT_MSG(
1073                         (current_aliases_num+1) == (temp = count_aliases(ALIAS_KEY)),
1074                         "Error: expecting " << (current_aliases_num+2) << " aliases, while found " << temp);
1075
1076         ckmc_key_s *get_AES_key = 0;
1077         RUNNER_ASSERT_MSG(
1078                         CKMC_ERROR_NONE == (temp = ckmc_get_key(key_alias.c_str(), policy_key.password, &get_AES_key)),
1079                         CKMCReadableError(temp));
1080         validate_AES_key(get_AES_key);
1081         ckmc_key_free(get_AES_key);
1082 }
1083
1084
1085 RUNNER_TEST(T3055_CAPI_deinit)
1086 {
1087         int temp;
1088
1089         RUNNER_ASSERT_MSG(
1090                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
1091                         CKMCReadableError(temp));
1092         RUNNER_ASSERT_MSG(
1093                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1094                         CKMCReadableError(temp));
1095 }
1096
1097
1098 RUNNER_TEST_GROUP_INIT(T306_CKMC_CAPI_CreateKeyPair);
1099
1100 RUNNER_TEST(T3061_CAPI_init)
1101 {
1102         remove_user_data(0);
1103         reset_user_data(USER_APP, USER_PASS);
1104 }
1105
1106 RUNNER_TEST(T3062_CAPI_CreateKeyPairRSA)
1107 {
1108         int temp;
1109
1110         size_t size = 1024;
1111         CKM::Alias private_key_alias = sharedDatabase("rsa-test-1");
1112         CKM::Alias public_key_alias = sharedDatabase("rsa-test-2");
1113         ckmc_policy_s policy_private_key;
1114         ckmc_policy_s policy_public_key;
1115
1116         policy_private_key.password = const_cast<char *>("privatepassword");
1117         policy_private_key.extractable = 0;
1118
1119         policy_public_key.password = NULL;
1120         policy_public_key.extractable = 1;
1121
1122         RUNNER_ASSERT_MSG(
1123                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_rsa(size, private_key_alias.c_str(), public_key_alias.c_str(), policy_private_key, policy_public_key)),
1124                         CKMCReadableError(temp));
1125
1126         // on next attempt to generate keys with the same alias, expect fail (alias exists)
1127         RUNNER_ASSERT_MSG(
1128                         CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_create_key_pair_rsa(size, private_key_alias.c_str(), public_key_alias.c_str(), policy_private_key, policy_public_key)),
1129                         CKMCReadableError(temp));
1130 }
1131
1132 RUNNER_TEST(T3063_CAPI_CreateKeyPairDSA)
1133 {
1134         int temp;
1135
1136         size_t size = 1024;
1137         CKM::Alias private_key_alias = sharedDatabase("dsa-test-1");
1138         CKM::Alias public_key_alias = sharedDatabase("dsa-test-2");
1139         ckmc_policy_s policy_private_key;
1140         ckmc_policy_s policy_public_key;
1141
1142         policy_private_key.password = const_cast<char *>("privatepassword");
1143         policy_private_key.extractable = 0;
1144
1145         policy_public_key.password = NULL;
1146         policy_public_key.extractable = 1;
1147
1148         RUNNER_ASSERT_MSG(
1149                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, private_key_alias.c_str(), public_key_alias.c_str(), policy_private_key, policy_public_key)),
1150                         CKMCReadableError(temp));
1151 }
1152
1153 RUNNER_TEST(T3064_CAPI_CreateKeyPairECDSA)
1154 {
1155         int temp;
1156
1157         ckmc_ec_type_e ectype = CKMC_EC_PRIME192V1;
1158         CKM::Alias private_key_alias = sharedDatabase("ecdsa-test-1");
1159         CKM::Alias public_key_alias = sharedDatabase("ecdsa-test-2");
1160         ckmc_policy_s policy_private_key;
1161         ckmc_policy_s policy_public_key;
1162
1163         policy_private_key.password = const_cast<char *>("privatepassword");
1164         policy_private_key.extractable = 0;
1165
1166         policy_public_key.password = NULL;
1167         policy_public_key.extractable = 1;
1168
1169         RUNNER_ASSERT_MSG(
1170                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_ecdsa(ectype, private_key_alias.c_str(), public_key_alias.c_str(), policy_private_key, policy_public_key)),
1171                         CKMCReadableError(temp));
1172 }
1173
1174 RUNNER_TEST(T3065_CAPI_deinit)
1175 {
1176         remove_user_data(0);
1177 }
1178
1179 // TODO
1180 //RUNNER_TEST_GROUP_INIT(T120_NEGATIVE_TESTS);
1181
1182
1183
1184 RUNNER_TEST_GROUP_INIT(T307_CKMC_CAPI_OCSP_TESTS);
1185
1186 RUNNER_TEST(T3071_CAPI_init)
1187 {
1188         remove_user_data(0);
1189 }
1190
1191 RUNNER_TEST(T3074_CAPI_ckmc_ocsp_check)
1192 {
1193     RUNNER_IGNORED_MSG("Temporary turned off. Require network feature.");
1194     std::string ee = TestData::getTestCertificateBase64(TestData::MBANK);
1195         std::string im = TestData::getTestCertificateBase64(TestData::SYMANTEC);
1196
1197         ckmc_cert_s c_cert;
1198         c_cert.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(ee.c_str()));
1199         c_cert.cert_size = ee.size();
1200         c_cert.data_format = CKMC_FORM_PEM;
1201
1202         ckmc_cert_s c_cert1;
1203         c_cert1.raw_cert = reinterpret_cast<unsigned char *>(const_cast<char *>(im.c_str()));
1204         c_cert1.cert_size = im.size();
1205         c_cert1.data_format = CKMC_FORM_PEM;
1206
1207         ckmc_cert_list_s untrustedcerts;
1208         untrustedcerts.cert = &c_cert1;
1209         untrustedcerts.next = NULL;
1210
1211         ckmc_cert_list_s *cert_chain_list;
1212
1213         int     tmp = ckmc_get_cert_chain(&c_cert, &untrustedcerts, &cert_chain_list);
1214         RUNNER_ASSERT_MSG(
1215                         CKMC_ERROR_NONE == tmp, CKMCReadableError(tmp));
1216
1217         RUNNER_ASSERT_MSG(cert_chain_list != NULL, "Wrong size of certificate chain.");
1218
1219         ckmc_ocsp_status_e ocsp_status;
1220         RUNNER_ASSERT_MSG(CKMC_ERROR_NONE == (tmp = ckmc_ocsp_check(cert_chain_list, &ocsp_status)), CKMCReadableError(tmp));
1221         RUNNER_ASSERT_MSG(ocsp_status == CKMC_OCSP_STATUS_GOOD, "Wrong status: " << static_cast<int>(ocsp_status));
1222 }
1223
1224 RUNNER_TEST(T3075_CAPI_deinit)
1225 {
1226         remove_user_data(0);
1227 }
1228
1229
1230 RUNNER_TEST_GROUP_INIT(T308_CAPI_CREATE_AND_VERIFY_SIGNATURE);
1231
1232 RUNNER_TEST(T3081_CAPI__init)
1233 {
1234         int temp;
1235
1236         RUNNER_ASSERT_MSG(
1237                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
1238                         CKMCReadableError(temp));
1239
1240         RUNNER_ASSERT_MSG(
1241                         CKMC_ERROR_NONE == (temp = ckmc_unlock_user_key(USER_APP, USER_PASS)),
1242                         CKMCReadableError(temp));
1243
1244         remove_user_data(0);
1245 }
1246
1247 RUNNER_TEST(T3082_CAPI__rsa_key_create_verify)
1248 {
1249         int temp;
1250
1251         std::string prv = "-----BEGIN RSA PRIVATE KEY-----\n"
1252                 "Proc-Type: 4,ENCRYPTED\n"
1253                 "DEK-Info: DES-EDE3-CBC,6C6507B11671DABC\n"
1254                 "\n"
1255                 "YiKNviNqc/V/i241CKtAVsNckesE0kcaka3VrY7ApXR+Va93YoEwVQ8gB9cE/eHH\n"
1256                 "S0j3ZS1PAVFM/qo4ZnPdMzaSLvTQw0GAL90wWgF3XQ+feMnWyBObEoQdGXE828TB\n"
1257                 "SLz4UOIQ55Dx6JSWTfEhwAlPs2cEWD14xvuxPzAEzBIYmWmBBsCN94YgFeRTzjH0\n"
1258                 "TImoYVMN60GgOfZWw6rXq9RaV5dY0Y6F1piypCLGD35VaXAutdHIDvwUGECPm7SN\n"
1259                 "w05jRro53E1vb4mYlZEY/bs4q7XEOI5+ZKT76Xn0oEJNX1KRL1h2q8fgUkm5j40M\n"
1260                 "uQj71aLR9KyIoQARwGLeRy09tLVjH3fj66CCMqaPcxcIRIyWi5yYBB0s53ipm6A9\n"
1261                 "CYuyc7MS2C0pOdWKsDvYsHR/36KUiIdPuhF4AbaTqqO0eWeuP7Na7dGK56Fl+ooi\n"
1262                 "cUpJr7cIqMl2vL25B0jW7d4TB3zwCEkVVD1fBPeNoZWo30z4bILcBqjjPkQfHZ2e\n"
1263                 "xNraG3qI4FHjoPT8JEE8p+PgwaMoINlICyIMKiCdvwz9yEnsHPy7FkmatpS+jFoS\n"
1264                 "mg8R9vMwgK/HGEm0dmb/7/a0XsG2jCDm6cOmJdZJFQ8JW7hFs3eOHpNlQYDChG2D\n"
1265                 "A1ExslqBtbpicywTZhzFdYU/hxeCr4UqcY27Zmhr4JlBPMyvadWKeOqCamWepjbT\n"
1266                 "T/MhWJbmWgZbI5s5sbpu7cOYubQcUIEsTaQXGx/KEzGo1HLn9tzSeQfP/nqjAD/L\n"
1267                 "T5t1Mb8o4LuV/fGIT33Q3i2FospJMqp2JINNzG18I6Fjo08PTvJ3row40Rb76+lJ\n"
1268                 "wN1IBthgBgsgsOdB6XNc56sV+uq2TACsNNWw+JnFRCkCQgfF/KUrvN+WireWq88B\n"
1269                 "9UPG+Hbans5A6K+y1a+bzfdYnKws7x8wNRyPxb7Vb2t9ZTl5PBorPLVGsjgf9N5X\n"
1270                 "tCdBlfJsUdXot+EOxrIczV5zx0JIB1Y9hrDG07RYkzPuJKxkW7skqeLo8oWGVpaQ\n"
1271                 "LGWvuebky1R75hcSuL3e4QHfjBHPdQ31fScB884tqkbhBAWr2nT9bYEmyT170bno\n"
1272                 "8QkyOSb99xZBX55sLDHs9p61sTJr2C9Lz/KaWQs+3hTkpwSjSRyjEMH2n491qiQX\n"
1273                 "G+kvLEnvtR8sl9zinorj/RfsxyPntAxudfY3qaYUu2QkLvVdfTVUVbxS/Fg8f7B3\n"
1274                 "hEjCtpKgFjPxQuHE3didNOr5xM7mkmLN/QA7yHVgdpE64T5mFgC3JcVRpcR7zBPH\n"
1275                 "3OeXHgjrhDfN8UIX/cq6gNgD8w7O0rhHa3mEXI1xP14ykPcJ7wlRuLm9P3fwx5A2\n"
1276                 "jQrVKJKw1Nzummmspn4VOpJY3LkH4Sxo4e7Soo1l1cxJpzmERwgMF+vGz1L70+DG\n"
1277                 "M0hVrz1PxlOsBBFgcdS4TB91DIs/RcFDqrJ4gOPNKCgBP+rgTXXLFcxUwJfE3lKg\n"
1278                 "Kmpwdne6FuQYX3eyRVAmPgOHbJuRQCh/V4fYo51UxCcEKeKy6UgOPEJlXksWGbH5\n"
1279                 "VFmlytYW6dFKJvjltSmK6L2r+TlyEQoXwTqe4bkfhB2LniDEq28hKQ==\n"
1280                 "-----END RSA PRIVATE KEY-----\n";
1281
1282         std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1283                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1284                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1285                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1286                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1287                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1288                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1289                 "zQIDAQAB\n"
1290                 "-----END PUBLIC KEY-----\n";
1291
1292         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1293
1294         CKM::Alias pub_alias = sharedDatabase("pub1");
1295         CKM::Alias pri_alias = sharedDatabase("prv1");
1296         const char *key_passwd = "1234";
1297         char *pri_passwd = NULL;
1298         char *pub_passwd = NULL;
1299         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1300         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1301         ckmc_raw_buffer_s *signature;
1302
1303         ckmc_key_s pubkey;
1304         pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1305         pubkey.key_size = pub.size();
1306         pubkey.key_type = CKMC_KEY_NONE;
1307         pubkey.password = NULL;
1308
1309         ckmc_policy_s pubpolicy;
1310         pubpolicy.password = pub_passwd;
1311         pubpolicy.extractable = 0;
1312
1313         ckmc_policy_s pripolicy;
1314         pripolicy.password = pri_passwd;
1315         pripolicy.extractable = 1;
1316
1317         ckmc_key_s prikey;
1318         prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1319         prikey.key_size = prv.size();
1320         prikey.key_type = CKMC_KEY_NONE;
1321         prikey.password = const_cast<char *>(key_passwd);
1322
1323
1324         RUNNER_ASSERT_MSG(
1325                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias.c_str(), prikey, pripolicy)),
1326                         CKMCReadableError(temp));
1327
1328         RUNNER_ASSERT_MSG(
1329                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias.c_str(), pubkey, pubpolicy)),
1330                         CKMCReadableError(temp));
1331
1332         RUNNER_ASSERT_MSG(
1333                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1334                                         pri_alias.c_str(),
1335                                         pri_passwd,
1336                                         msg_buff,
1337                                         hash_algo,
1338                                         pad_algo,
1339                                         &signature)),
1340                         CKMCReadableError(temp));
1341
1342         RUNNER_ASSERT_MSG(
1343                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1344                                         pub_alias.c_str(),
1345                                         pub_passwd,
1346                                         msg_buff,
1347                                         *signature,
1348                                         hash_algo,
1349                                         pad_algo)),
1350                         CKMCReadableError(temp));
1351 }
1352
1353 RUNNER_TEST(T3083_CAPI__rsa_key_create_verify_negative)
1354 {
1355         int temp;
1356
1357         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message asdfaslkdfjlksadjf test");
1358         CKM::Alias pub_alias = sharedDatabase("pub1");
1359         CKM::Alias pri_alias = sharedDatabase("prv1");
1360         char *pri_passwd = NULL;
1361         char *pub_passwd = NULL;
1362         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1363         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1364         ckmc_raw_buffer_s *signature;
1365
1366         RUNNER_ASSERT_MSG(
1367                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1368                                         pri_alias.c_str(),
1369                                         pri_passwd,
1370                                         msg_buff,
1371                                         hash_algo,
1372                                         pad_algo,
1373                                         &signature)),
1374                         CKMCReadableError(temp));
1375
1376         RUNNER_ASSERT_MSG(
1377                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1378                                         pub_alias.c_str(),
1379                                         pub_passwd,
1380                                         msg_buff,
1381                                         *signature,
1382                                         hash_algo,
1383                                         pad_algo)),
1384                         CKMCReadableError(temp));
1385
1386         RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1387         memcpy((void*)signature->data, "BROKEN", 6);
1388
1389         RUNNER_ASSERT_MSG(
1390                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1391                                         pub_alias.c_str(),
1392                                         pub_passwd,
1393                                         msg_buff,
1394                                         *signature,
1395                                         hash_algo,
1396                                         pad_algo)),
1397                         CKMCReadableError(temp));
1398 }
1399
1400 RUNNER_TEST(T3084_CAPI__ec_key_create_verify)
1401 {
1402         int temp;
1403
1404         std::string prv = "-----BEGIN EC PRIVATE KEY-----\n"
1405                 "MHQCAQEEIJNud6U4h8EM1rASn4W5vQOJELTaVPQTUiESaBULvQUVoAcGBSuBBAAK\n"
1406                 "oUQDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT05YHeT7vK0w08AUL1HCH5nFV\n"
1407                 "ljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1408                 "-----END EC PRIVATE KEY-----\n";
1409
1410         std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1411                 "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEL1R+hgjiFrdjbUKRNOxUG8ze9nveD9zT\n"
1412                 "05YHeT7vK0w08AUL1HCH5nFVljePBYSxe6CybFiseayaxRxjA+iF1g==\n"
1413                 "-----END PUBLIC KEY-----\n";
1414
1415         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1416         CKM::Alias pri_alias = sharedDatabase("ecprv2");
1417         CKM::Alias pub_alias = sharedDatabase("ecpub2");
1418         char *key_passwd = NULL;
1419         char *pri_passwd = NULL;
1420         char *pub_passwd = NULL;
1421         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1422         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1423         ckmc_raw_buffer_s *signature;
1424
1425         ckmc_key_s pubkey;
1426         pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1427         pubkey.key_size = pub.size();
1428         pubkey.key_type = CKMC_KEY_NONE;
1429         pubkey.password = NULL;
1430
1431         ckmc_policy_s pubpolicy;
1432         pubpolicy.password = pub_passwd;
1433         pubpolicy.extractable = 1;
1434
1435         ckmc_key_s prikey;
1436         prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1437         prikey.key_size = prv.size();
1438         prikey.key_type = CKMC_KEY_NONE;
1439         prikey.password = key_passwd;
1440
1441         ckmc_policy_s pripolicy;
1442         pripolicy.password = pri_passwd;
1443         pripolicy.extractable = 0;
1444
1445         RUNNER_ASSERT_MSG(
1446                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias.c_str(), pubkey, pubpolicy)),
1447                         CKMCReadableError(temp));
1448         RUNNER_ASSERT_MSG(
1449                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias.c_str(), prikey, pripolicy)),
1450                         CKMCReadableError(temp));
1451
1452         RUNNER_ASSERT_MSG(
1453                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1454                                         pri_alias.c_str(),
1455                                         pri_passwd,
1456                                         msg_buff,
1457                                         hash_algo,
1458                                         pad_algo,
1459                                         &signature)),
1460                         CKMCReadableError(temp));
1461
1462         RUNNER_ASSERT_MSG(
1463                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1464                                         pub_alias.c_str(),
1465                                         pub_passwd,
1466                                         msg_buff,
1467                                         *signature,
1468                                         hash_algo,
1469                                         pad_algo)),
1470                         CKMCReadableError(temp));
1471
1472         RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1473         memcpy((void*)signature->data, "BROKEN", 6);
1474
1475         RUNNER_ASSERT_MSG(
1476                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1477                                         pub_alias.c_str(),
1478                                         pub_passwd,
1479                                         msg_buff,
1480                                         *signature,
1481                                         hash_algo,
1482                                         pad_algo)),
1483                         CKMCReadableError(temp));
1484 }
1485
1486 RUNNER_TEST(T3085_CAPI__rsa_cert_create_verify_signature)
1487 {
1488         int temp;
1489
1490         std::string prv =
1491                 "-----BEGIN RSA PRIVATE KEY-----\n"
1492                 "MIICXQIBAAKBgQDCKb9BkTdOjCTXKPi/H5FSGuyrgzORBtR3nCTg7SRnL47zNGEj\n"
1493                 "l2wkgsY9ZO3UJHm0gy5KMjWeCuUVkSD3G46J9obg1bYJivCQBJKxfieA8sWOtNq1\n"
1494                 "M8emHGK8o3sjaRklrngmk2xSCs5vFJVlCluzAYUmrPDm64C3+n4yW4pBCQIDAQAB\n"
1495                 "AoGAd1IWgiHO3kuLvFome7XXpaB8P27SutZ6rcLcewnhLDRy4g0XgTrmL43abBJh\n"
1496                 "gdSkooVXZity/dvuKpHUs2dQ8W8zYiFFsHfu9qqLmLP6SuBPyUCvlUDH5BGfjjxI\n"
1497                 "5qGWIowj/qGHKpbQ7uB+Oe2BHwbHao0zFZIkfKqY0mX9U00CQQDwF/4zQcGS1RX/\n"
1498                 "229gowTsvSGVmm8cy1jGst6xkueEuOEZ/AVPO1fjavz+nTziUk4E5lZHAj18L6Hl\n"
1499                 "iO29LRujAkEAzwbEWVhfTJewCZIFf3sY3ifXhGZhVKDHVzPBNyoft8Z+09DMHTJb\n"
1500                 "EYg85MIbR73aUyIWsEci/CPk6LPRNv47YwJAHtQF2NEFqPPhakPjzjXAaSFz0YDN\n"
1501                 "6ZWWpZTMEWL6hUkz5iE9EUpeY54WNB8+dRT6XZix1VZNTMfU8uMdG6BSHwJBAKYM\n"
1502                 "gm47AGz5eVujwD8op6CACk+KomRzdI+P1lh9s+T+E3mnDiAY5IxiXp0Ix0K6lyN4\n"
1503                 "wwPuerQLwi2XFKZsMYsCQQDOiSQFP9PfXh9kFzN6e89LxOdnqC/r9i5GDB3ea8eL\n"
1504                 "SCRprpzqOXZvOP1HBAEjsJ6k4f8Dqj1fm+y8ZcgAZUPr\n"
1505                 "-----END RSA PRIVATE KEY-----\n";
1506
1507         std::string pub =
1508                 "-----BEGIN CERTIFICATE-----\n"
1509                 "MIICijCCAfOgAwIBAgIJAMvaNHQ1ozT8MA0GCSqGSIb3DQEBBQUAMF4xCzAJBgNV\n"
1510                 "BAYTAlBMMQ0wCwYDVQQIDARMb2R6MQ0wCwYDVQQHDARMb2R6MRAwDgYDVQQKDAdT\n"
1511                 "YW1zdW5nMREwDwYDVQQLDAhTZWN1cml0eTEMMAoGA1UEAwwDQ0tNMB4XDTE0MDcw\n"
1512                 "MjEyNDE0N1oXDTE3MDcwMTEyNDE0N1owXjELMAkGA1UEBhMCUEwxDTALBgNVBAgM\n"
1513                 "BExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1bmcxETAPBgNVBAsM\n"
1514                 "CFNlY3VyaXR5MQwwCgYDVQQDDANDS00wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJ\n"
1515                 "AoGBAMIpv0GRN06MJNco+L8fkVIa7KuDM5EG1HecJODtJGcvjvM0YSOXbCSCxj1k\n"
1516                 "7dQkebSDLkoyNZ4K5RWRIPcbjon2huDVtgmK8JAEkrF+J4DyxY602rUzx6YcYryj\n"
1517                 "eyNpGSWueCaTbFIKzm8UlWUKW7MBhSas8ObrgLf6fjJbikEJAgMBAAGjUDBOMB0G\n"
1518                 "A1UdDgQWBBQuW9DuITahZJ6saVZZI0aBlis5vzAfBgNVHSMEGDAWgBQuW9DuITah\n"
1519                 "ZJ6saVZZI0aBlis5vzAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4GBAB2X\n"
1520                 "GNtJopBJR3dCpzDONknr/c6qcsPVa3nH4c7qzy6F+4bgqa5IObnoF8zUrvD2sMAO\n"
1521                 "km3C/N+Qzt8Rb7ORM6U4tlPp1kZ5t6PKjghhNaiYwVm9A/Zm+wyAmRIkQiYDr4MX\n"
1522                 "e+bRAkPmJeEWpaav1lvvBnFzGSGJrnSSeWUegGyn\n"
1523                 "-----END CERTIFICATE-----\n";
1524
1525         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1526
1527         CKM::Alias pri_alias = sharedDatabase("prv3");
1528         CKM::Alias pub_alias = sharedDatabase("pub3");
1529         char *key_passwd = NULL;
1530         char *pri_passwd = NULL;
1531         char *pub_passwd = NULL;
1532         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1533         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1534         ckmc_raw_buffer_s *signature;
1535
1536         ckmc_cert_s cert;
1537         cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1538         cert.cert_size = pub.size();
1539         cert.data_format = CKMC_FORM_PEM;
1540
1541         ckmc_policy_s certpolicy;
1542         certpolicy.password = pub_passwd;
1543         certpolicy.extractable = 1;
1544
1545         ckmc_key_s prikey;
1546         prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1547         prikey.key_size = prv.size();
1548         prikey.key_type = CKMC_KEY_NONE;
1549         prikey.password = key_passwd;
1550
1551         ckmc_policy_s pripolicy;
1552         pripolicy.password = pri_passwd;
1553         pripolicy.extractable = 0;
1554
1555         RUNNER_ASSERT_MSG(
1556                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias.c_str(), cert, certpolicy)),
1557                         CKMCReadableError(temp));
1558         RUNNER_ASSERT_MSG(
1559                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias.c_str(), prikey, pripolicy)),
1560                         CKMCReadableError(temp));
1561
1562
1563         RUNNER_ASSERT_MSG(
1564                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1565                                         pri_alias.c_str(),
1566                                         pri_passwd,
1567                                         msg_buff,
1568                                         hash_algo,
1569                                         pad_algo,
1570                                         &signature)),
1571                         CKMCReadableError(temp));
1572
1573         RUNNER_ASSERT_MSG(
1574                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1575                                         pub_alias.c_str(),
1576                                         pub_passwd,
1577                                         msg_buff,
1578                                         *signature,
1579                                         hash_algo,
1580                                         pad_algo)),
1581                         CKMCReadableError(temp));
1582
1583         RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1584         memcpy((void*)signature->data, "BROKEN", 6);
1585
1586         RUNNER_ASSERT_MSG(
1587                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1588                                         pub_alias.c_str(),
1589                                         pub_passwd,
1590                                         msg_buff,
1591                                         *signature,
1592                                         hash_algo,
1593                                         pad_algo)),
1594                         CKMCReadableError(temp));
1595 }
1596
1597 RUNNER_TEST(T3086_CAPI__dsa_ext_key_create_verify_with_negative)
1598 {
1599         int temp;
1600
1601         const std::string pub = "-----BEGIN PUBLIC KEY-----\n"
1602                 "MIIBtzCCASwGByqGSM44BAEwggEfAoGBALeveaD/EheW+ws1YuW77f344+brkEzm\n"
1603                 "BVfFYHr7t+jwu6nQe341SoESJG+PCgrrhy76KNDCfveiwEoWufVHnI4bYBU/ClzP\n"
1604                 "A3amf6c5yud45ZR/b6OiAuew6ohY0mQGnzqeio8BaCsZaJ6EziCSlkdIDJisSfPg\n"
1605                 "nlWHqf4AwHVdAhUA7I1JQ7sBFJ+N19w3Omu+aO8EG08CgYEAldagy/Ccxhh43cZu\n"
1606                 "AZQxgJLCcp1jg6NdPMdkZ2TcSijvaVxBu+gjEGOqN5Os2V6UF7S/k/rjHYmcX9ux\n"
1607                 "gpjkC31yTNrKyERIAFIYZtG2K7LVBUZq5Fgm7I83QBVchJ2PA7mBaugJFEhNjbhK\n"
1608                 "NRip5UH38le1YDZ/IiA+svFOpeoDgYQAAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+\n"
1609                 "hq0c3FGUCtGbVOqg2KPqMBgwSb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdO\n"
1610                 "OSCQciDXnRfSqKbT6tjDTgR5jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rC\n"
1611                 "YMYCBhubtrVaLmc=\n"
1612                 "-----END PUBLIC KEY-----";
1613
1614         const std::string priv = "-----BEGIN DSA PRIVATE KEY-----\n"
1615                 "MIIBvAIBAAKBgQC3r3mg/xIXlvsLNWLlu+39+OPm65BM5gVXxWB6+7fo8Lup0Ht+\n"
1616                 "NUqBEiRvjwoK64cu+ijQwn73osBKFrn1R5yOG2AVPwpczwN2pn+nOcrneOWUf2+j\n"
1617                 "ogLnsOqIWNJkBp86noqPAWgrGWiehM4gkpZHSAyYrEnz4J5Vh6n+AMB1XQIVAOyN\n"
1618                 "SUO7ARSfjdfcNzprvmjvBBtPAoGBAJXWoMvwnMYYeN3GbgGUMYCSwnKdY4OjXTzH\n"
1619                 "ZGdk3Eoo72lcQbvoIxBjqjeTrNlelBe0v5P64x2JnF/bsYKY5At9ckzayshESABS\n"
1620                 "GGbRtiuy1QVGauRYJuyPN0AVXISdjwO5gWroCRRITY24SjUYqeVB9/JXtWA2fyIg\n"
1621                 "PrLxTqXqAoGAPT91aEgwFdulzmHlvr3k+GBCE9z+hq0c3FGUCtGbVOqg2KPqMBgw\n"
1622                 "Sb4MC0msQys4DTVZhLJI+C5eIPEHgfBMqY1ZNJdOOSCQciDXnRfSqKbT6tjDTgR5\n"
1623                 "jmh5bG1Q8QFeBTHCDsQHoQYWgx0nyu12lASN80rCYMYCBhubtrVaLmcCFQC0IB4m\n"
1624                 "u1roOuaPY+Hl19BlTE2qdw==\n"
1625                 "-----END DSA PRIVATE KEY-----";
1626
1627         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1628
1629         CKM::Alias pub_alias = sharedDatabase("dsa-pub1");
1630         CKM::Alias pri_alias = sharedDatabase("dsa-prv1");
1631         char *pri_passwd = NULL;
1632         char *pub_passwd = NULL;
1633         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1634         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1635         ckmc_raw_buffer_s *signature = NULL;
1636
1637         ckmc_key_s pubkey;
1638         pubkey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1639         pubkey.key_size = pub.size();
1640         pubkey.key_type = CKMC_KEY_NONE;
1641         pubkey.password = NULL;
1642
1643         ckmc_policy_s pubpolicy;
1644         pubpolicy.password = pub_passwd;
1645         pubpolicy.extractable = 0;
1646
1647         ckmc_policy_s pripolicy;
1648         pripolicy.password = pri_passwd;
1649         pripolicy.extractable = 1;
1650
1651         ckmc_key_s prikey;
1652         prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(priv.c_str()));
1653         prikey.key_size = priv.size();
1654         prikey.key_type = CKMC_KEY_NONE;
1655         prikey.password = NULL;
1656
1657
1658         RUNNER_ASSERT_MSG(
1659                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias.c_str(), prikey, pripolicy)),
1660                         CKMCReadableError(temp));
1661
1662         RUNNER_ASSERT_MSG(
1663                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pub_alias.c_str(), pubkey, pubpolicy)),
1664                         CKMCReadableError(temp));
1665
1666         RUNNER_ASSERT_MSG(
1667                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1668                                         pri_alias.c_str(),
1669                                         pri_passwd,
1670                                         msg_buff,
1671                                         hash_algo,
1672                                         pad_algo,
1673                                         &signature)),
1674                         CKMCReadableError(temp));
1675
1676         // positive test
1677         RUNNER_ASSERT_MSG(
1678                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1679                                         pub_alias.c_str(),
1680                                         pub_passwd,
1681                                         msg_buff,
1682                                         *signature,
1683                                         hash_algo,
1684                                         pad_algo)),
1685                         CKMCReadableError(temp));
1686
1687         // negative test
1688         ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1689         RUNNER_ASSERT_MSG(
1690                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1691                                         pub_alias.c_str(),
1692                                         pub_passwd,
1693                                         invalid_msg_buff,
1694                                         *signature,
1695                                         hash_algo,
1696                                         pad_algo)),
1697                         CKMCReadableError(temp));
1698
1699         ckmc_buffer_free(signature);
1700 }
1701
1702 RUNNER_TEST(T3087_CAPI__dsa_int_key_create_verify_with_negative)
1703 {
1704         int temp;
1705
1706         size_t size = 1024;
1707         ckmc_policy_s policy_private_key;
1708         ckmc_policy_s policy_public_key;
1709
1710         policy_private_key.password = NULL;
1711         policy_private_key.extractable = 1;
1712
1713         policy_public_key.password = NULL;
1714         policy_public_key.extractable = 1;
1715
1716         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1717
1718         CKM::Alias pub_alias = sharedDatabase("dsa-pub2");
1719         CKM::Alias pri_alias = sharedDatabase("dsa-prv2");
1720
1721         RUNNER_ASSERT_MSG(
1722                         CKMC_ERROR_NONE == (temp = ckmc_create_key_pair_dsa(size, pri_alias.c_str(), pub_alias.c_str(), policy_private_key, policy_public_key)),
1723                         "Error=" << temp);
1724
1725         char *pri_passwd = NULL;
1726         char *pub_passwd = NULL;
1727         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1728         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1729         ckmc_raw_buffer_s *signature;
1730
1731         ckmc_key_s *pubkey = NULL;
1732         ckmc_key_s *prikey = NULL;
1733         RUNNER_ASSERT_MSG(
1734                         CKMC_ERROR_NONE == (temp = ckmc_get_key(pri_alias.c_str(), 0, &prikey)),
1735                         CKMCReadableError(temp));
1736
1737         RUNNER_ASSERT_MSG(
1738                         CKMC_ERROR_NONE == (temp = ckmc_get_key(pub_alias.c_str(), 0, &pubkey)),
1739                         CKMCReadableError(temp));
1740
1741         RUNNER_ASSERT_MSG(
1742                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1743                                         pri_alias.c_str(),
1744                                         pri_passwd,
1745                                         msg_buff,
1746                                         hash_algo,
1747                                         pad_algo,
1748                                         &signature)),
1749                         CKMCReadableError(temp));
1750
1751         // positive test
1752         RUNNER_ASSERT_MSG(
1753                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1754                                         pub_alias.c_str(),
1755                                         pub_passwd,
1756                                         msg_buff,
1757                                         *signature,
1758                                         hash_algo,
1759                                         pad_algo)),
1760                         CKMCReadableError(temp));
1761
1762         // negative test
1763         ckmc_raw_buffer_s invalid_msg_buff = prepare_message_buffer("invalid message test");
1764         RUNNER_ASSERT_MSG(
1765                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1766                                         pub_alias.c_str(),
1767                                         pub_passwd,
1768                                         invalid_msg_buff,
1769                                         *signature,
1770                                         hash_algo,
1771                                         pad_algo)),
1772                         CKMCReadableError(temp));
1773
1774         ckmc_key_free(prikey);
1775         ckmc_key_free(pubkey);
1776         ckmc_buffer_free(signature);
1777 }
1778
1779 RUNNER_TEST(T3088_CAPI__ecdsa_cert_create_verify_signature)
1780 {
1781         int temp;
1782
1783         std::string prv =
1784                 "-----BEGIN EC PRIVATE KEY-----\n"
1785                 "MIH8AgEBBBRPb/2utS5aCtyuwmzIHpU6LH3mc6CBsjCBrwIBATAgBgcqhkjOPQEB\n"
1786                 "AhUA/////////////////////3////8wQwQU/////////////////////3////wE\n"
1787                 "FByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UEKQRK\n"
1788                 "lrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAAAAAA\n"
1789                 "AAAAAfTI+Seu08p1IlcCAQGhLAMqAATehLqu61gKC3Tgr4wQMVoguAhhG3Uwwz8u\n"
1790                 "ELyhe7yPCAuOoLZlTLgf\n"
1791                 "-----END EC PRIVATE KEY-----\n";
1792
1793         std::string pub =
1794                 "-----BEGIN CERTIFICATE-----\n"
1795                 "MIICfDCCAjqgAwIBAgIJANIytpeTKlXBMAkGByqGSM49BAEwXjELMAkGA1UEBhMC\n"
1796                 "UEwxDTALBgNVBAgMBExvZHoxDTALBgNVBAcMBExvZHoxEDAOBgNVBAoMB1NhbXN1\n"
1797                 "bmcxETAPBgNVBAsMCFNlY3VyaXR5MQwwCgYDVQQDDANDS00wHhcNMTQwNzAyMTI0\n"
1798                 "MTQ3WhcNMTcwNzAxMTI0MTQ3WjBeMQswCQYDVQQGEwJQTDENMAsGA1UECAwETG9k\n"
1799                 "ejENMAsGA1UEBwwETG9kejEQMA4GA1UECgwHU2Ftc3VuZzERMA8GA1UECwwIU2Vj\n"
1800                 "dXJpdHkxDDAKBgNVBAMMA0NLTTCB6jCBuwYHKoZIzj0CATCBrwIBATAgBgcqhkjO\n"
1801                 "PQEBAhUA/////////////////////3////8wQwQU/////////////////////3//\n"
1802                 "//wEFByXvvxUvXqLZaz4n4HU1K3FZfpFAxUAEFPN5CwU1pbmdodWFRdTO/P4M0UE\n"
1803                 "KQRKlrVojvVzKEZkaYlow4u5E8v8giOmKFUxaJR9WdzJEgQjUTd6xfsyAhUBAAAA\n"
1804                 "AAAAAAAAAfTI+Seu08p1IlcCAQEDKgAE3oS6rutYCgt04K+MEDFaILgIYRt1MMM/\n"
1805                 "LhC8oXu8jwgLjqC2ZUy4H6NQME4wHQYDVR0OBBYEFELElWx3kbLo55Cfn1vywsEZ\n"
1806                 "ccsmMB8GA1UdIwQYMBaAFELElWx3kbLo55Cfn1vywsEZccsmMAwGA1UdEwQFMAMB\n"
1807                 "Af8wCQYHKoZIzj0EAQMxADAuAhUAumC4mGoyK97SxTvVBQ+ELfCbxEECFQCbMJ72\n"
1808                 "Q1oBry6NEc+lLFmWMDesAA==\n"
1809                 "-----END CERTIFICATE-----\n";
1810
1811         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
1812
1813         CKM::Alias pri_alias = sharedDatabase("prv4");
1814         CKM::Alias pub_alias = sharedDatabase("pub4");
1815         char *key_passwd = NULL;
1816         char *pri_passwd = NULL;
1817         char *pub_passwd = NULL;
1818         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
1819         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
1820         ckmc_raw_buffer_s *signature;
1821
1822         ckmc_cert_s cert;
1823         cert.raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(pub.c_str()));
1824         cert.cert_size = pub.size();
1825         cert.data_format = CKMC_FORM_PEM;
1826
1827         ckmc_policy_s certpolicy;
1828         certpolicy.password = pub_passwd;
1829         certpolicy.extractable = 1;
1830
1831         ckmc_key_s prikey;
1832         prikey.raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(prv.c_str()));
1833         prikey.key_size = prv.size();
1834         prikey.key_type = CKMC_KEY_NONE;
1835         prikey.password = key_passwd;
1836
1837         ckmc_policy_s pripolicy;
1838         pripolicy.password = pri_passwd;
1839         pripolicy.extractable = 0;
1840
1841
1842         RUNNER_ASSERT_MSG(
1843                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(pub_alias.c_str(), cert, certpolicy)),
1844                         CKMCReadableError(temp));
1845         RUNNER_ASSERT_MSG(
1846                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pri_alias.c_str(), prikey, pripolicy)),
1847                         CKMCReadableError(temp));
1848
1849         RUNNER_ASSERT_MSG(
1850                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
1851                                         pri_alias.c_str(),
1852                                         pri_passwd,
1853                                         msg_buff,
1854                                         hash_algo,
1855                                         pad_algo,
1856                                         &signature)),
1857                         CKMCReadableError(temp));
1858
1859         RUNNER_ASSERT_MSG(
1860                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
1861                                         pub_alias.c_str(),
1862                                         pub_passwd,
1863                                         msg_buff,
1864                                         *signature,
1865                                         hash_algo,
1866                                         pad_algo)),
1867                         CKMCReadableError(temp));
1868
1869         RUNNER_ASSERT_MSG(signature->size > 6, "Signature is too small");
1870         memcpy((void*)signature->data, "BROKEN", 6);
1871
1872         RUNNER_ASSERT_MSG(
1873                         CKMC_ERROR_VERIFICATION_FAILED == (temp = ckmc_verify_signature(
1874                                         pub_alias.c_str(),
1875                                         pub_passwd,
1876                                         msg_buff,
1877                                         *signature,
1878                                         hash_algo,
1879                                         pad_algo)),
1880                         CKMCReadableError(temp));
1881 }
1882
1883 RUNNER_TEST(T3089_CAPI__deinit)
1884 {
1885         remove_user_data(0);
1886 }
1887
1888
1889 //#######################################################################################
1890
1891 void _assertKey(ckmc_key_s *key, unsigned char *raw_key, unsigned int key_size, ckmc_key_type_e key_type, char *password)
1892 {
1893         RUNNER_ASSERT_MSG(key->key_size == key_size, "Key Size Error" );
1894         RUNNER_ASSERT_MSG(key->key_type == key_type, "Key Type Error" );
1895
1896         if(key->password != NULL && password != NULL) {
1897                 RUNNER_ASSERT_MSG(strcmp(key->password, password) == 0, "Password Error" );
1898         }else if(key->password == NULL && password == NULL) {
1899                 RUNNER_ASSERT_MSG(true, "Password Error" );
1900         }else {
1901                 RUNNER_ASSERT_MSG(false, "Password Error" );
1902         }
1903
1904         if(key->raw_key != NULL && raw_key != NULL) {
1905                 for(unsigned int i=0; i<key_size; i++) {
1906                         RUNNER_ASSERT_MSG((key->raw_key)[i] == raw_key[i],  "Raw Key Error" );
1907                 }
1908         }else if(key->raw_key == NULL && raw_key == NULL) {
1909                 RUNNER_ASSERT_MSG(true,  "Raw Key Error" );
1910         }else {
1911                 RUNNER_ASSERT_MSG(false,  "Raw Key Error" );
1912         }
1913 }
1914
1915 RUNNER_TEST_GROUP_INIT(T309_CKMC_CAPI_TYPES);
1916
1917 RUNNER_TEST(T3091_CAPI_TYPE_init)
1918 {
1919         remove_user_data(0);
1920         reset_user_data(USER_APP, USER_PASS);
1921 }
1922
1923 RUNNER_TEST(T3092_CAPI_TYPE_KEY)
1924 {
1925         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1926                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1927                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1928                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1929                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1930                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1931                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1932                 "zQIDAQAB\n"
1933                 "-----END PUBLIC KEY-----";
1934
1935         unsigned char *raw_key = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1936         unsigned int key_size = keyPem.size();
1937         ckmc_key_type_e key_type = CKMC_KEY_NONE;
1938         char *password = const_cast< char *>("");
1939
1940         ckmc_key_s *key;
1941         ckmc_key_new(raw_key, key_size, key_type, password, &key);
1942
1943         _assertKey(key, raw_key, key_size, key_type, password);
1944         ckmc_key_free(key);
1945
1946         char *passwordNull = NULL;
1947         ckmc_key_s *key2;
1948         ckmc_key_new(raw_key, key_size, key_type, passwordNull, &key2);
1949         ckmc_key_free(key2);
1950 }
1951
1952 RUNNER_TEST(T3093_CAPI_TYPE_BUFFER)
1953 {
1954         std::string keyPem = "-----BEGIN PUBLIC KEY-----\n"
1955                 "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2b1bXDa+S8/MGWnMkru4\n"
1956                 "T4tUddtZNi0NVjQn9RFH1NMa220GsRhRO56F77FlSVFKfSfVZKIiWg6C+DVCkcLf\n"
1957                 "zXJ/Z0pvwOQYBAqVMFjV6efQGN0JzJ1Unu7pPRiZl7RKGEI+cyzzrcDyrLLrQ2W7\n"
1958                 "0ZySkNEOv6Frx9JgC5NExuYY4lk2fQQa38JXiZkfyzif2em0px7mXbyf5LjccsKq\n"
1959                 "v1e+XLtMsL0ZefRcqsP++NzQAI8fKX7WBT+qK0HJDLiHrKOTWYzx6CwJ66LD/vvf\n"
1960                 "j55xtsKDLVDbsotvf8/m6VLMab+vqKk11TP4tq6yo0mwyTADvgl1zowQEO9I1W6o\n"
1961                 "zQIDAQAB\n"
1962                 "-----END PUBLIC KEY-----";
1963
1964         unsigned char *data = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(keyPem.c_str()));
1965         unsigned int size = keyPem.size();
1966
1967         ckmc_raw_buffer_s *buff;
1968         ckmc_buffer_new(data, size, &buff);
1969
1970         RUNNER_ASSERT_MSG(buff->size == size, "Size Error" );
1971
1972         if(buff->data != NULL && data != NULL) {
1973                 for(unsigned int i=0; i<size; i++) {
1974                         RUNNER_ASSERT_MSG((buff->data)[i] == data[i],  "Raw data Error" );
1975                 }
1976         }else if(buff->data == NULL && data == NULL) {
1977                 RUNNER_ASSERT_MSG(true,  "Raw data Error" );
1978         }else {
1979                 RUNNER_ASSERT_MSG(false,  "Raw data Error" );
1980         }
1981
1982         ckmc_buffer_free(buff);
1983 }
1984
1985 RUNNER_TEST(T3094_CAPI_TYPE_CERT)
1986 {
1987         std::string certPem = TestData::getTestCertificateBase64(TestData::GIAG2);
1988
1989         unsigned char *raw_cert = const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(certPem.c_str()));
1990         unsigned int size = certPem.size();
1991         ckmc_data_format_e form = CKMC_FORM_PEM;
1992
1993         ckmc_cert_s *ckmCert;
1994         ckmc_cert_new(raw_cert, size, form, &ckmCert);
1995
1996         RUNNER_ASSERT_MSG(ckmCert->cert_size == size, "Size Error" );
1997
1998         if(ckmCert->raw_cert != NULL && raw_cert != NULL) {
1999                 for(unsigned int i=0; i<size; i++) {
2000                         RUNNER_ASSERT_MSG((ckmCert->raw_cert)[i] == raw_cert[i],  "Raw data Error" );
2001                 }
2002         }else if(ckmCert->raw_cert == NULL && raw_cert == NULL) {
2003                 RUNNER_ASSERT_MSG(true,  "raw_cert Error" );
2004         }else {
2005                 RUNNER_ASSERT_MSG(false,  "raw_cert Error" );
2006         }
2007
2008         RUNNER_ASSERT_MSG(ckmCert->data_format == form, "ckmc_cert_form Error" );
2009
2010         ckmc_cert_free(ckmCert);
2011 }
2012
2013
2014 RUNNER_TEST(T3095_CAPI_TYPE_load_cert_file)
2015 {
2016         int ret;
2017
2018         std::string certStr = TestData::getTestCertificateBase64(TestData::MBANK);
2019
2020         const char *file_name = "/tmp/ckmc_test_cert.pem";
2021         remove(file_name);
2022
2023         FILE* cert_file;
2024         cert_file = fopen(file_name, "w");
2025         fprintf(cert_file, "%s",certStr.c_str());
2026         fclose(cert_file);
2027
2028         ckmc_cert_s *pcert;
2029
2030         RUNNER_ASSERT_MSG(
2031                         CKMC_ERROR_NONE == (ret = ckmc_load_cert_from_file(file_name, &pcert)),
2032                         CKMCReadableError(ret));
2033
2034         RUNNER_ASSERT_MSG(
2035                         pcert != NULL && pcert->cert_size > 0,"Fail to load cert from file.");
2036
2037         CKM::Alias lcert_alias = sharedDatabase("lcert_alias");
2038         ckmc_policy_s policy;
2039         policy.password = NULL;
2040         policy.extractable = 1;
2041
2042         RUNNER_ASSERT_MSG(
2043                         CKMC_ERROR_NONE == (ret = ckmc_save_cert(lcert_alias.c_str(), *pcert, policy)),
2044                         CKMCReadableError(ret));
2045
2046         remove(file_name);
2047 }
2048
2049 RUNNER_TEST(T3096_CAPI_TYPE_load_p12_file) {
2050         const char *p12file = "/usr/share/ckm-test/capi-t3096.p12";
2051         const char *password = "password";
2052
2053         int temp;
2054
2055         ckmc_key_s *private_key = NULL;
2056         ckmc_cert_s *cert = NULL;
2057         ckmc_cert_list_s *ca_cert_list = NULL;
2058
2059         RUNNER_ASSERT_MSG(
2060                         CKMC_ERROR_NONE == (temp = ckmc_load_from_pkcs12_file(p12file, password,
2061                                         &private_key, &cert, &ca_cert_list)),
2062                         "Error=" << temp);
2063         RUNNER_ASSERT_MSG(private_key != NULL, "Null private_key");
2064         RUNNER_ASSERT_MSG(cert != NULL, "Null cert");
2065         RUNNER_ASSERT_MSG(ca_cert_list != NULL, "Null ca_cert_list");
2066
2067         ckmc_policy_s policy;
2068         policy.password = NULL;
2069         policy.extractable = 1;
2070
2071
2072         CKM::Alias pkey_alias = sharedDatabase("pkey_alias");
2073         RUNNER_ASSERT_MSG(
2074                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias.c_str(), *private_key, policy)),
2075                         CKMCReadableError(temp));
2076
2077         CKM::Alias cert_alias = sharedDatabase("cert_alias");
2078         RUNNER_ASSERT_MSG(
2079                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias.c_str(), *cert, policy)),
2080                         CKMCReadableError(temp));
2081         std::string caCertAlias = sharedDatabase("ca_cert_alias_");
2082         const char *idx = "0";
2083         int cnt = 0;
2084         ckmc_cert_list_s *tmpList = ca_cert_list;
2085         while(tmpList != NULL) {
2086                 caCertAlias.append(idx);
2087                 RUNNER_ASSERT_MSG(
2088                                 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2089                                 CKMCReadableError(temp));
2090                 tmpList = tmpList->next;
2091                 cnt ++;
2092         }
2093
2094         RUNNER_ASSERT_MSG(cnt ==  2, "Invalid CA Cert Count");
2095
2096         ckmc_key_free(private_key);
2097         ckmc_cert_free(cert);
2098         ckmc_cert_list_all_free(ca_cert_list);
2099 }
2100
2101 RUNNER_TEST(T3097_CAPI_TYPE_load_p12_file2) {
2102         const char *p12file = "/usr/share/ckm-test/capi-t3096.p12";
2103         const char *password = "password";
2104
2105         int temp;
2106
2107         ckmc_pkcs12_s *ppkcs12 = NULL;
2108
2109         RUNNER_ASSERT_MSG(
2110                         CKMC_ERROR_NONE == (temp = ckmc_pkcs12_load(p12file, password, &ppkcs12)),
2111                         CKMCReadableError(temp));
2112         RUNNER_ASSERT_MSG(ppkcs12->priv_key != NULL, "Null private_key");
2113         RUNNER_ASSERT_MSG(ppkcs12->cert != NULL, "Null cert");
2114         RUNNER_ASSERT_MSG(ppkcs12->ca_chain != NULL, "Null ca_cert_list");
2115
2116         ckmc_policy_s policy;
2117         policy.password = NULL;
2118         policy.extractable = 1;
2119
2120
2121         CKM::Alias pkey_alias = sharedDatabase("pkey_alias2");
2122         RUNNER_ASSERT_MSG(
2123                         CKMC_ERROR_NONE == (temp = ckmc_save_key(pkey_alias.c_str(), *(ppkcs12->priv_key), policy)),
2124                         CKMCReadableError(temp));
2125
2126         CKM::Alias cert_alias = sharedDatabase("cert_alias2");
2127         RUNNER_ASSERT_MSG(
2128                         CKMC_ERROR_NONE == (temp = ckmc_save_cert(cert_alias.c_str(), *(ppkcs12->cert), policy)),
2129                         CKMCReadableError(temp));
2130         std::string caCertAlias = sharedDatabase("ca_cert_alias_2_");
2131         const char *idx = "0";
2132         int cnt = 0;
2133         ckmc_cert_list_s *tmpList = ppkcs12->ca_chain;
2134         while(tmpList != NULL) {
2135                 caCertAlias.append(idx);
2136                 RUNNER_ASSERT_MSG(
2137                                 CKMC_ERROR_NONE == (temp = ckmc_save_cert(caCertAlias.c_str(), *(tmpList->cert), policy)),
2138                                 CKMCReadableError(temp));
2139                 tmpList = tmpList->next;
2140                 cnt ++;
2141         }
2142
2143         RUNNER_ASSERT_MSG(cnt ==  2, "Invalid CA Cert Count");
2144
2145         ckmc_pkcs12_free(ppkcs12);
2146 }
2147
2148 RUNNER_TEST(T3098_CAPI_TYPE_deinit)
2149 {
2150         int temp;
2151         remove_user_data(0);
2152         RUNNER_ASSERT_MSG(
2153                         CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2154                         CKMCReadableError(temp));
2155         RUNNER_ASSERT_MSG(
2156                         CKMC_ERROR_NONE == (temp = ckmc_remove_user_data(USER_APP)),
2157                         CKMCReadableError(temp));
2158 }
2159
2160 RUNNER_TEST_GROUP_INIT(T310_CKMC_CAPI_PKCS12);
2161
2162 namespace
2163 {
2164 CKM::Alias alias_PKCS_exportable = sharedDatabase("CAPI-test-PKCS-export");
2165 CKM::Alias alias_PKCS_not_exportable = sharedDatabase("CAPI-test-PKCS-no-export");
2166 }
2167
2168 RUNNER_TEST(T3101_CAPI_PKCS12_init)
2169 {
2170         remove_user_data(0);
2171 }
2172
2173 RUNNER_TEST(T3102_CAPI_PKCS12_negative_wrong_password)
2174 {
2175         const char *wrong_passwd = "wrong";
2176         ckmc_pkcs12_s *ppkcs12 = NULL;
2177         int temp;
2178         RUNNER_ASSERT_MSG(
2179                         CKMC_ERROR_INVALID_FORMAT == (temp = ckmc_pkcs12_load("/usr/share/ckm-test/test1801.pkcs12", wrong_passwd, &ppkcs12)),
2180                         CKMCReadableError(temp));
2181 }
2182
2183 RUNNER_TEST(T3103_CAPI_PKCS12_add_bundle_with_chain_certs)
2184 {
2185         ckmc_pkcs12_s *ppkcs12 = NULL;
2186         int temp;
2187         RUNNER_ASSERT_MSG(
2188                         CKMC_ERROR_NONE == (temp = ckmc_pkcs12_load("/usr/share/ckm-test/pkcs.p12", NULL, &ppkcs12)),
2189                         CKMCReadableError(temp));
2190
2191         RUNNER_ASSERT_MSG(NULL != ppkcs12->cert, "no certificate in PKCS12");
2192         RUNNER_ASSERT_MSG(NULL != ppkcs12->priv_key, "no private key in PKCS12");
2193         RUNNER_ASSERT_MSG(NULL != ppkcs12->ca_chain, "no chain certificates in PKCS12");
2194
2195         // save to the CKM
2196         ckmc_policy_s exportable;
2197         exportable.password = NULL;
2198         exportable.extractable = 1;
2199         ckmc_policy_s notExportable;
2200         notExportable.password = NULL;
2201         notExportable.extractable = 0;
2202
2203         RUNNER_ASSERT_MSG(
2204                         CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_exportable.c_str(), ppkcs12, exportable, exportable)),
2205                         CKMCReadableError(temp));
2206         RUNNER_ASSERT_MSG(
2207                         CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_exportable.c_str(), ppkcs12, exportable, exportable)),
2208                         CKMCReadableError(temp));
2209         RUNNER_ASSERT_MSG(
2210                         CKMC_ERROR_NONE == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable.c_str(), ppkcs12, notExportable, notExportable)),
2211                         CKMCReadableError(temp));
2212         RUNNER_ASSERT_MSG(
2213                         CKMC_ERROR_DB_ALIAS_EXISTS == (temp = ckmc_save_pkcs12(alias_PKCS_not_exportable.c_str(), ppkcs12, notExportable, notExportable)),
2214                         CKMCReadableError(temp));
2215
2216         // try to lookup key
2217         ckmc_key_s *key_lookup = NULL;
2218         RUNNER_ASSERT_MSG(
2219                         CKMC_ERROR_NONE == (temp = ckmc_get_key(alias_PKCS_exportable.c_str(), NULL, &key_lookup)),
2220                         CKMCReadableError(temp));
2221         ckmc_key_free(key_lookup);
2222         key_lookup = NULL;
2223         RUNNER_ASSERT_MSG(
2224                         CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_key(alias_PKCS_not_exportable.c_str(), "", &key_lookup)),
2225                         CKMCReadableError(temp));
2226         ckmc_key_free(key_lookup);
2227
2228         // try to lookup certificate
2229         ckmc_cert_s *cert_lookup = NULL;
2230         RUNNER_ASSERT_MSG(
2231                         CKMC_ERROR_NONE == (temp = ckmc_get_cert(alias_PKCS_exportable.c_str(), NULL, &cert_lookup)),
2232                         CKMCReadableError(temp));
2233         ckmc_cert_free(cert_lookup);
2234         cert_lookup = NULL;
2235         RUNNER_ASSERT_MSG(
2236                         CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_cert(alias_PKCS_not_exportable.c_str(), NULL, &cert_lookup)),
2237                         CKMCReadableError(temp));
2238         ckmc_cert_free(cert_lookup);
2239 }
2240
2241 RUNNER_TEST(T3104_CAPI_PKCS12_get_PKCS)
2242 {
2243         int temp;
2244         ckmc_pkcs12_s *pkcs = NULL;
2245
2246         // fail - no entry
2247         RUNNER_ASSERT_MSG(
2248                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_pkcs12(sharedDatabase("i-do-not-exist").c_str(), NULL, NULL, &pkcs)),
2249                         CKMCReadableError(temp));
2250         ckmc_pkcs12_free(pkcs);
2251         pkcs = NULL;
2252
2253         // fail - not exportable
2254         RUNNER_ASSERT_MSG(
2255                         CKMC_ERROR_NOT_EXPORTABLE == (temp = ckmc_get_pkcs12(alias_PKCS_not_exportable.c_str(), NULL, NULL, &pkcs)),
2256                         CKMCReadableError(temp));
2257         ckmc_pkcs12_free(pkcs);
2258         pkcs = NULL;
2259
2260         // success - exportable
2261         RUNNER_ASSERT_MSG(
2262                         CKMC_ERROR_NONE == (temp = ckmc_get_pkcs12(alias_PKCS_exportable.c_str(), NULL, NULL, &pkcs)),
2263                         CKMCReadableError(temp));
2264
2265         RUNNER_ASSERT_MSG(NULL != pkcs->cert, "no certificate in PKCS12");
2266         RUNNER_ASSERT_MSG(NULL != pkcs->priv_key, "no private key in PKCS12");
2267         RUNNER_ASSERT_MSG(NULL != pkcs->ca_chain, "no chain certificates in PKCS12");
2268         size_t cntr = 0;
2269         ckmc_cert_list_s *iter = pkcs->ca_chain;
2270         do {
2271                 cntr ++;
2272                 iter = iter->next;
2273         } while(iter);
2274         RUNNER_ASSERT_MSG(2 == cntr, "invalid number of chain certificates in PKCS12");
2275
2276         ckmc_pkcs12_free(pkcs);
2277 }
2278
2279 RUNNER_TEST(T3105_CAPI_PKCS12_create_and_verify_signature)
2280 {
2281         ckmc_raw_buffer_s msg_buff = prepare_message_buffer("message test");
2282
2283         int temp;
2284         ckmc_hash_algo_e hash_algo = CKMC_HASH_SHA256;
2285         ckmc_rsa_padding_algo_e pad_algo = CKMC_PKCS1_PADDING;
2286         ckmc_raw_buffer_s *signature = NULL;
2287
2288         RUNNER_ASSERT_MSG(
2289                         CKMC_ERROR_NONE == (temp = ckmc_create_signature(
2290                                         alias_PKCS_exportable.c_str(),
2291                                         NULL,
2292                                         msg_buff,
2293                                         hash_algo,
2294                                         pad_algo,
2295                                         &signature)),
2296                         CKMCReadableError(temp));
2297
2298         RUNNER_ASSERT_MSG(
2299                         CKMC_ERROR_NONE == (temp = ckmc_verify_signature(
2300                                         alias_PKCS_exportable.c_str(),
2301                                         NULL,
2302                                         msg_buff,
2303                                         *signature,
2304                                         hash_algo,
2305                                         pad_algo)),
2306                         CKMCReadableError(temp));
2307 }
2308
2309 RUNNER_TEST(T3106_CAPI_PKCS12_remove_bundle_with_chain_certs)
2310 {
2311         int tmp;
2312
2313         // remove the whole PKCS12 bundles
2314         RUNNER_ASSERT_MSG(
2315                         CKMC_ERROR_NONE == (tmp = ckmc_remove_alias(alias_PKCS_exportable.c_str())),
2316                         CKMCReadableError(tmp));
2317         RUNNER_ASSERT_MSG(
2318                         CKMC_ERROR_NONE == (tmp = ckmc_remove_alias(alias_PKCS_not_exportable.c_str())),
2319                         CKMCReadableError(tmp));
2320
2321         // expect lookup fails due to unknown alias
2322         // try to lookup key
2323         ckmc_key_s *key_lookup = NULL;
2324         RUNNER_ASSERT_MSG(
2325                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_exportable.c_str(), NULL, &key_lookup)),
2326                         CKMCReadableError(tmp));
2327         ckmc_key_free(key_lookup);
2328         key_lookup = NULL;
2329         RUNNER_ASSERT_MSG(
2330                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_key(alias_PKCS_not_exportable.c_str(), NULL, &key_lookup)),
2331                         CKMCReadableError(tmp));
2332         ckmc_key_free(key_lookup);
2333
2334         // try to lookup certificate
2335         ckmc_cert_s *cert_lookup = NULL;
2336         RUNNER_ASSERT_MSG(
2337                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_exportable.c_str(), NULL, &cert_lookup)),
2338                         CKMCReadableError(tmp));
2339         ckmc_cert_free(cert_lookup);
2340         cert_lookup = NULL;
2341         RUNNER_ASSERT_MSG(
2342                         CKMC_ERROR_DB_ALIAS_UNKNOWN == (tmp = ckmc_get_cert(alias_PKCS_not_exportable.c_str(), NULL, &cert_lookup)),
2343                         CKMCReadableError(tmp));
2344         ckmc_cert_free(cert_lookup);
2345 }
2346
2347 RUNNER_TEST(T3109_CAPI_PKCS12_deinit)
2348 {
2349         remove_user_data(0);
2350 }
2351
2352
2353 RUNNER_TEST_GROUP_INIT(T320_CAPI_EMPTY_DATABASE);
2354
2355 RUNNER_TEST(T3201_CAPI_unlock_database)
2356 {
2357         reset_user_data(USER_APP, USER_PASS);
2358 }
2359
2360 RUNNER_CHILD_TEST(T3202_CAPI_get_data_from_empty_database)
2361 {
2362         ScopedDBUnlock unlock(USER_APP, USER_PASS);
2363         ScopedAccessProvider ap(TEST_LABEL);
2364         ap.allowAPI("key-manager::api-storage", "rw");
2365         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2366
2367         int temp;
2368         CKM::Alias alias = "mykey";
2369         char *password = NULL;
2370         ckmc_key_s *test_key = NULL;
2371
2372         RUNNER_ASSERT_MSG(
2373                 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(alias.c_str(), password, &test_key)),
2374                 "Error=" << temp);
2375
2376         RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2377 }
2378
2379 RUNNER_CHILD_TEST(T3203_CAPI_lock_database)
2380 {
2381     RUNNER_IGNORED_MSG("Temporary turned off. The default password for database must be turn off for this test.");
2382     ScopedDBUnlock unlock(USER_APP, USER_PASS);
2383         ScopedAccessProvider ap(TEST_LABEL);
2384         ap.allowAPI("key-manager::api-storage", "rw");
2385         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2386
2387         int temp;
2388         RUNNER_ASSERT_MSG( CKMC_ERROR_NONE == (temp = ckmc_lock_user_key(USER_APP)),
2389                 CKMCReadableError(temp));
2390 }
2391
2392 RUNNER_CHILD_TEST(T3204_CAPI_get_data_from_locked_database)
2393 {
2394     RUNNER_IGNORED_MSG("Temporary turned off. The default password for database must be turn off for this test.");
2395         ScopedAccessProvider ap(TEST_LABEL);
2396         ap.allowAPI("key-manager::api-storage", "rw");
2397         ap.applyAndSwithToUser(USER_APP, GROUP_APP);
2398
2399         int temp;
2400         CKM::Alias alias = "mykey";
2401         char *password = NULL;
2402         ckmc_key_s *test_key = NULL;
2403
2404 #ifndef PASSWORD_PROTECTION_DISABLE
2405         RUNNER_ASSERT_MSG(
2406                 CKMC_ERROR_DB_LOCKED == (temp = ckmc_get_key(alias.c_str(), password, &test_key)),
2407                 CKMCReadableError(temp));
2408
2409         RUNNER_ASSERT_MSG(NULL == test_key, "Key value should not be changed");
2410 #else
2411         RUNNER_ASSERT_MSG(
2412                 CKMC_ERROR_DB_ALIAS_UNKNOWN == (temp = ckmc_get_key(alias.c_str(), password, &test_key)),
2413                 CKMCReadableError(temp));
2414 #endif
2415 }
2416
2417 RUNNER_TEST(T3204_deinit)
2418 {
2419         remove_user_data(USER_APP);
2420 }
2421