tests/pkcs12/new_test_cases.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  *    Licensed under the Apache License, Version 2.0 (the "License");
   5  *    you may not use this file except in compliance with the License.
   6  *    You may obtain a copy of the License at
   7  *
   8  *        http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  *    Unless required by applicable law or agreed to in writing, software
  11  *    distributed under the License is distributed on an "AS IS" BASIS,
  12  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  *    See the License for the specific language governing permissions and
  14  *    limitations under the License.
  15  */
  16 /*
  17  * @file        new_test_cases.cpp
  18  * @author      Madhan A K (madhan.ak@samsung.com)
  19  * @author      Kyungwook Tak (k.tak@samsung.com)
  20  * @version     2.0
  21  * @brief       PKCS#12 test cases.
  22  */
  23
  24 #include <unistd.h>
  25 #include <cstring>
  26 #include <new>
  27
  28 #include <openssl/err.h>
  29 #include <openssl/pkcs12.h>
  30 #include <openssl/sha.h>
  31 #include <openssl/x509.h>
  32 #include <openssl/pem.h>
  33
  34 #include <cert-svc/cinstance.h>
  35 #include <cert-svc/ccert.h>
  36 #include <cert-svc/cpkcs12.h>
  37 #include <cert-svc/cerror.h>
  38 #include <cert-svc/cprimitives.h>
  39
  40 #include <dpl/test/test_runner.h>
  41
  42 static CertSvcInstance instance;
  43
  44 static CertSvcString wrapper_certsvc_string_new(const char *cStr)
  45 {
  46         CertSvcString certsvcStr;
  47
  48         if (!cStr) {
  49                 certsvcStr.privateHandler = NULL;
  50                 return certsvcStr;
  51         }
  52
  53         RUNNER_ASSERT_MSG(
  54                 certsvc_string_new(instance, cStr, strlen(cStr), &certsvcStr) == CERTSVC_SUCCESS,
  55                 "Failed to certsvc_string_new");
  56
  57         return certsvcStr;
  58 }
  59
  60 const CertStoreType allStoreType = (CertStoreType)(WIFI_STORE | VPN_STORE | EMAIL_STORE);
  61
  62 #define CREATE_INSTANCE \
  63   certsvc_instance_new(&instance);
  64 #define FREE_INSTANCE  \
  65   certsvc_instance_free(instance);
  66
  67 RUNNER_TEST(CERTSVC_PKCS12_1001_certsvc_get_root_cert_list)
  68 {
  69         CREATE_INSTANCE
  70
  71         CertSvcStoreCertList* certList = NULL;
  72         size_t length = 0;
  73         int result = certsvc_pkcs12_get_certificate_list_from_store(instance, SYSTEM_STORE, DISABLED, &certList, &length);
  74         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
  75
  76         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
  77         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
  78
  79         FREE_INSTANCE
  80 }
  81
  82 RUNNER_TEST(CERTSVC_PKCS12_1002_certsvc_set_cert_to_disabled_and_get_status_for_system_store)
  83 {
  84         CertStatus status = ENABLED;
  85         int result;
  86
  87         CREATE_INSTANCE
  88
  89         CertSvcString Alias = wrapper_certsvc_string_new("Certum_Root_CA.pem");
  90
  91         result = certsvc_pkcs12_get_certificate_status_from_store(instance, SYSTEM_STORE, Alias, &status);
  92         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
  93
  94         // if status is already disabled, roll it back to enable and go on
  95         if (status == DISABLED) {
  96                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, SYSTEM_STORE, DISABLED, Alias, ENABLED);
  97                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Roll back certificate status to system store failed.");
  98         }
  99
 100         result = certsvc_pkcs12_set_certificate_status_to_store(instance, SYSTEM_STORE, DISABLED, Alias, DISABLED);
 101         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 102
 103         result = certsvc_pkcs12_get_certificate_status_from_store(instance, SYSTEM_STORE, Alias, &status);
 104         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 105         RUNNER_ASSERT_MSG(status == DISABLED, "invalid status from system store cert");
 106
 107         result = certsvc_pkcs12_set_certificate_status_to_store(instance, SYSTEM_STORE, DISABLED, Alias, ENABLED);
 108         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 109
 110         result = certsvc_pkcs12_get_certificate_status_from_store(instance, SYSTEM_STORE, Alias, &status);
 111         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 112         RUNNER_ASSERT_MSG(status == ENABLED, "invalid status from system store cert");
 113
 114         certsvc_string_free(Alias);
 115
 116         FREE_INSTANCE
 117 }
 118
 119 /* Install a CRT file to individual stores */
 120 RUNNER_TEST(CERTSVC_PKCS12_1003_add_pem_file_in_individual_store)
 121 {
 122         int result;
 123
 124         CREATE_INSTANCE
 125
 126         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifi-server.pem");
 127         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 128
 129         CertSvcString Alias = wrapper_certsvc_string_new("PEM-wifi-server-1");
 130         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 131         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PEM file to WIFI store failed.");
 132         certsvc_string_free(Alias);
 133
 134         Alias = wrapper_certsvc_string_new("PEM-wifi-server-2");
 135         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 136         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PEM file to VPN store failed.");
 137         certsvc_string_free(Alias);
 138
 139         Alias = wrapper_certsvc_string_new("PEM-wifi-server-3");
 140         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 141         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PEM file to EMAIL store failed.");
 142         certsvc_string_free(Alias);
 143
 144         certsvc_string_free(Path);
 145
 146         CertSvcStoreCertList *certList = NULL;
 147         size_t length = 0;
 148         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 149         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 150
 151         CertSvcStoreCertList *certListOrig = certList;
 152         int count = 0;
 153         CertSvcString strSubject;
 154         CertSvcString strIssuer;
 155         CertSvcCertificate certificate;
 156         while (certList) {
 157                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 158                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get certificate from store.");
 159
 160                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &strSubject);
 161                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get string field.");
 162
 163                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &strIssuer);
 164                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get string field.");
 165
 166                 certsvc_string_free(strSubject);
 167                 certsvc_string_free(strIssuer);
 168                 certsvc_certificate_free(certificate);
 169                 certList = certList->next;
 170                 count++;
 171         }
 172
 173         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 174
 175         FREE_INSTANCE
 176 }
 177
 178 RUNNER_TEST(CERTSVC_PKCS12_1004_add_pem_file_in_all_store)
 179 {
 180         int result;
 181
 182         CREATE_INSTANCE
 183
 184         CertSvcString Alias = wrapper_certsvc_string_new("PEM-wifi-server-all-store");
 185         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifi-server.pem");
 186         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 187
 188         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 189         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PEM file to all store failed.");
 190
 191         CertSvcStoreCertList *certList = NULL;
 192         size_t length = 0;
 193         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 194         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list failed");
 195
 196         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 197         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list failed");
 198
 199         certsvc_string_free(Alias);
 200         certsvc_string_free(Path);
 201
 202         FREE_INSTANCE
 203 }
 204
 205 RUNNER_TEST(CERTSVC_PKCS12_1005_add_crt_file_in_individual_store)
 206 {
 207         int result;
 208
 209         CREATE_INSTANCE
 210
 211         CertSvcString Alias = wrapper_certsvc_string_new("CRT-TestingCRT1");
 212         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/Testing.crt");
 213         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 214
 215         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 216         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing CRT file to WIFI store failed.");
 217
 218         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 219         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing CRT file to VPN store failed.");
 220
 221         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 222         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing CRT file to EMAIL store failed.");
 223
 224         CertSvcStoreCertList *certList = NULL;
 225         size_t length = 0;
 226         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 227         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 228
 229         CertSvcStoreCertList *certListOrig = certList;
 230         int count = 0;
 231         CertSvcString strSubject;
 232         CertSvcString strIssuer;
 233         CertSvcCertificate certificate;
 234         while (certList) {
 235                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 236                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 237
 238                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &strSubject);
 239                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 240
 241                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &strIssuer);
 242                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 243
 244                 certsvc_string_free(strSubject);
 245                 certsvc_string_free(strIssuer);
 246                 certsvc_certificate_free(certificate);
 247                 certList = certList->next;
 248                 count++;
 249         }
 250
 251         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 252
 253         FREE_INSTANCE
 254 }
 255
 256 RUNNER_TEST(CERTSVC_PKCS12_1006_add_crt_file_in_all_store)
 257 {
 258         int result;
 259
 260         CREATE_INSTANCE
 261
 262         CertSvcString Alias = wrapper_certsvc_string_new("CRT-TestingCRT1-all-store");
 263         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/Testing.crt");
 264         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 265
 266         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 267         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing CRT file to all store failed.");
 268
 269         CertSvcStoreCertList *certList = NULL;
 270         size_t length = 0;
 271         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 272         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 273
 274         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 275         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 276
 277         certsvc_string_free(Alias);
 278         certsvc_string_free(Path);
 279
 280         FREE_INSTANCE
 281 }
 282
 283 RUNNER_TEST(CERTSVC_PKCS12_1007_install_p12_file_to_individual_store)
 284 {
 285         int result;
 286
 287         CREATE_INSTANCE
 288
 289         CertSvcString Alias = wrapper_certsvc_string_new("P12-WifiUser");
 290         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifiuser.p12");
 291         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 292
 293         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 294         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing p12 file to WIFI store failed.");
 295
 296         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 297         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing p12 file to VPN store failed.");
 298
 299         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 300         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing p12 file to EMAIL store failed.");
 301
 302         CertSvcStoreCertList* certList = NULL;
 303         size_t length = 0;
 304         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 305         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 306
 307         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 308         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 309
 310         certsvc_string_free(Alias);
 311         certsvc_string_free(Path);
 312         certsvc_string_free(Pass);
 313
 314         FREE_INSTANCE
 315 }
 316
 317 RUNNER_TEST(CERTSVC_PKCS12_1008_install_p12_file_to_all_store)
 318 {
 319         int result;
 320
 321         CREATE_INSTANCE
 322
 323         CertSvcString Alias = wrapper_certsvc_string_new("P12-WifiUser-all-store");
 324         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifiuser.p12");
 325         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 326
 327         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 328         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing p12 file to WIFI store failed.");
 329
 330         CertSvcStoreCertList* certList = NULL;
 331         size_t length = 0;
 332         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 333         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 334
 335         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 336         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 337
 338         certsvc_string_free(Alias);
 339         certsvc_string_free(Path);
 340         certsvc_string_free(Pass);
 341
 342         FREE_INSTANCE
 343 }
 344
 345 RUNNER_TEST(CERTSVC_PKCS12_1009_install_pfx_file_to_individual_store)
 346 {
 347         int result;
 348
 349         CREATE_INSTANCE
 350
 351         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer");
 352         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifiserver.pfx");
 353         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 354
 355         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 356         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 357
 358         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 359         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to VPN store failed.");
 360
 361         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 362         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to EMAIL store failed.");
 363
 364         CertSvcStoreCertList* certList = NULL;
 365         size_t length = 0;
 366         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 367         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 368
 369         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 370         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 371
 372         certsvc_string_free(Alias);
 373         certsvc_string_free(Path);
 374         certsvc_string_free(Pass);
 375
 376         FREE_INSTANCE
 377 }
 378
 379 RUNNER_TEST(CERTSVC_PKCS12_1010_install_pfx_file_to_all_store)
 380 {
 381         int result;
 382
 383         CREATE_INSTANCE
 384
 385         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer-all-store");
 386         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifiserver.pfx");
 387         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 388
 389         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 390         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 391
 392         CertSvcStoreCertList* certList = NULL;
 393         size_t length = 0;
 394         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 395         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 396
 397         result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 398         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 399
 400         certsvc_string_free(Alias);
 401         certsvc_string_free(Path);
 402         certsvc_string_free(Pass);
 403
 404         FREE_INSTANCE
 405 }
 406
 407 /* Getting all end user & root certificate list from WIFI,VPN,EMAIL store */
 408 RUNNER_TEST(CERTSVC_PKCS12_1011_get_all_end_user_certificate_from_store)
 409 {
 410         int result;
 411
 412         CREATE_INSTANCE
 413
 414         CertSvcStoreCertList *certList = NULL;
 415         size_t length;
 416         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, WIFI_STORE, &certList, &length);
 417         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting end user certificate list from WIFI_STORE failed.");
 418         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 419
 420         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, VPN_STORE, &certList, &length);
 421         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting end user certificate list from VPN_STORE failed.");
 422         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 423
 424         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, EMAIL_STORE, &certList, &length);
 425         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting end user certificate list from EMAIL_STORE failed.");
 426         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 427
 428         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, WIFI_STORE, &certList, &length);
 429         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting root certificate list from WIFI_STORE failed.");
 430         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 431
 432         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, VPN_STORE, &certList, &length);
 433         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting root certificate list from VPN_STORE failed.");
 434         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 435
 436         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, EMAIL_STORE, &certList, &length);
 437         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting root certificate list from EMAIL_STORE failed.");
 438         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 439
 440         FREE_INSTANCE
 441 }
 442
 443 RUNNER_TEST(CERTSVC_PKCS12_1012_delete_all_cert_from_multiple_store)
 444 {
 445         int result;
 446         CertSvcString gname;
 447
 448         CREATE_INSTANCE
 449
 450         CertSvcStoreCertList *certList = NULL;
 451         size_t length;
 452         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 453         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 454
 455         CertSvcStoreCertList *certListOrig = certList;
 456         while (certList) {
 457                 gname = wrapper_certsvc_string_new(certList->gname);
 458                 result = certsvc_pkcs12_delete_certificate_from_store(instance, certList->storeType, gname);
 459                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Deleting certificate from store failed.");
 460
 461                 certsvc_string_free(gname);
 462
 463                 certList = certList->next;
 464         }
 465
 466         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 467
 468         FREE_INSTANCE
 469 }
 470
 471 RUNNER_TEST(CERTSVC_PKCS12_1013_install_pfx_file_to_one_store_and_get_list_from_multiple_store)
 472 {
 473         int result;
 474
 475         CREATE_INSTANCE
 476
 477         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer-one-store");
 478         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifiserver.pfx");
 479         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 480
 481         int isUnique = 0;
 482         result = certsvc_pkcs12_check_alias_exists_in_store(instance, allStoreType, Alias, &isUnique);
 483         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "check alias exists in store failed. result : " << result);
 484
 485         if (!isUnique) {
 486                 /* TODO: remove certificate which already exists and test continue */
 487                 RUNNER_ASSERT_MSG(0, "Remove certificate which already exists and test continue");
 488         }
 489
 490         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 491         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to EMAIL_STORE failed.");
 492
 493         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 494         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to WIFI_STORE failed.");
 495
 496         CertSvcStoreCertList *certList = NULL;
 497         size_t length = 0;
 498         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 499         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from all store failed");
 500
 501         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 502
 503         certsvc_string_free(Alias);
 504         certsvc_string_free(Path);
 505         certsvc_string_free(Pass);
 506
 507         FREE_INSTANCE
 508 }
 509
 510 RUNNER_TEST(CERTSVC_PKCS12_1014_installing_pfx_without_password_to_individual_store)
 511 {
 512         int result;
 513
 514         CREATE_INSTANCE
 515
 516         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer-without-password");
 517         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/without_pass.p12");
 518         CertSvcString Pass = wrapper_certsvc_string_new("");
 519
 520         int isUnique = 0;
 521         result = certsvc_pkcs12_check_alias_exists_in_store(instance, allStoreType, Alias, &isUnique);
 522         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "check alias exists in store failed. result : " << result);
 523
 524         if (!isUnique) {
 525                 /* TODO: remove certificate which already exists and test continue */
 526                 RUNNER_ASSERT_MSG(0, "Remove certificate which already exists and test continue");
 527         }
 528
 529         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 530         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Importing PFX file to all store failed. result : " << result );
 531
 532         certsvc_string_free(Alias);
 533         certsvc_string_free(Path);
 534
 535         FREE_INSTANCE
 536 }
 537
 538 RUNNER_TEST(CERTSVC_PKCS12_1015_get_certificate_from_store) {
 539
 540         int result;
 541
 542         CREATE_INSTANCE
 543
 544         CertSvcStoreCertList *certList = NULL;
 545         size_t length;
 546         result = certsvc_pkcs12_get_certificate_list_from_store(instance, allStoreType, DISABLED, &certList, &length);
 547         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from all store failed.");
 548         if (length == 0 || !certList) {
 549                 /* TODO: add any cert to store for testing */
 550                 RUNNER_ASSERT_MSG(0, "add any cert in store for testing");
 551         }
 552
 553         CertSvcStoreCertList *certListOrig = certList;
 554         CertSvcString strSubject;
 555         CertSvcString strIssuer;
 556         CertSvcCertificate certificate;
 557         while (certList) {
 558                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 559                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get certificate from store.");
 560
 561                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &strSubject);
 562                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get string field.");
 563
 564                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &strIssuer);
 565                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 566
 567                 certsvc_string_free(strSubject);
 568                 certsvc_string_free(strIssuer);
 569                 certsvc_certificate_free(certificate);
 570                 certList = certList->next;
 571         }
 572
 573         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 574
 575         FREE_INSTANCE
 576 }
 577
 578 RUNNER_TEST(CERTSVC_PKCS12_1016_get_certificate_from_system_store)
 579 {
 580         int result;
 581
 582         CREATE_INSTANCE
 583
 584         CertSvcStoreCertList *certList = NULL;
 585         size_t length = 0;
 586         result = certsvc_pkcs12_get_certificate_list_from_store(instance, SYSTEM_STORE, DISABLED, &certList, &length);
 587         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 588         if (length == 0 || !certList) {
 589                 /* TODO: add any cert to store for testing */
 590                 RUNNER_ASSERT_MSG(0, "add any cert in store for testing");
 591         }
 592
 593         CertSvcStoreCertList *certListOrig = certList;
 594         CertSvcString strSubject;
 595         CertSvcString strIssuer;
 596         CertSvcCertificate certificate;
 597         while (certList) {
 598                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 599                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 600
 601                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &strSubject);
 602                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 603
 604                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &strIssuer);
 605                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 606
 607                 certsvc_string_free(strSubject);
 608                 certsvc_string_free(strIssuer);
 609                 certsvc_certificate_free(certificate);
 610                 certList = certList->next;
 611         }
 612
 613         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 614
 615         FREE_INSTANCE
 616 }
 617
 618 RUNNER_TEST(CERTSVC_PKCS12_1017_load_cert_list_from_store)
 619 {
 620         int result;
 621
 622         CREATE_INSTANCE
 623
 624         CertSvcStoreCertList *certListTemp = NULL;
 625         size_t length = 0;
 626         result = certsvc_pkcs12_get_certificate_list_from_store(instance, VPN_STORE, DISABLED, &certListTemp, &length);
 627         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from VPN_STORE failed.");
 628         if (length == 0 || !certListTemp) {
 629                 /* TODO: add any cert to store for testing */
 630                 RUNNER_ASSERT_MSG(0, "add any cert in store for testing");
 631         }
 632
 633         CertSvcString strSubject;
 634         CertSvcString strIssuer;
 635         CertSvcCertificate cert;
 636         CertSvcString gname = wrapper_certsvc_string_new(certListTemp->gname);
 637
 638         CertSvcCertificateList certList;
 639         result = certsvc_pkcs12_load_certificate_list_from_store(instance, VPN_STORE, gname, &certList);
 640         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Load certificate list form VPN_STORE failed.");
 641         certsvc_string_free(gname);
 642
 643         length = 0;
 644         result = certsvc_certificate_list_get_length(certList, &length);
 645         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate list get length failed.");
 646         RUNNER_ASSERT_MSG(length > 0, "No certificate loaded.");
 647
 648         for (size_t i = 0; i < length; i++) {
 649                 result = certsvc_certificate_list_get_one(certList, i, &cert);
 650                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_certificate_list_get_one failed.");
 651
 652                 result = certsvc_certificate_get_string_field(cert, CERTSVC_SUBJECT, &strSubject);
 653                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get string field.");
 654
 655                 result = certsvc_certificate_get_string_field(cert, CERTSVC_ISSUER_COMMON_NAME, &strIssuer);
 656                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to get string field.");
 657
 658                 certsvc_string_free(strSubject);
 659                 certsvc_string_free(strIssuer);
 660                 certsvc_certificate_free(cert);
 661         }
 662
 663         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListTemp);
 664
 665         FREE_INSTANCE
 666 }
 667
 668 RUNNER_TEST(CERTSVC_PKCS12_1018_get_duplicate_private_key)
 669 {
 670         const char *privatekey_path = "/usr/share/cert-svc/pkcs12/temp.txt";
 671         int result;
 672
 673         CREATE_INSTANCE
 674
 675         CertSvcStoreCertList *certListTemp = NULL;
 676         size_t length = 0;
 677         result = certsvc_pkcs12_get_certificate_list_from_store(instance, VPN_STORE, DISABLED, &certListTemp, &length);
 678         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from VPN_STORE failed.");
 679         if (length == 0 || !certListTemp) {
 680                 /* TODO: add any cert to store for testing */
 681                 RUNNER_ASSERT_MSG(0, "add any cert in store for testing");
 682         }
 683
 684         CertSvcString gname = wrapper_certsvc_string_new(certListTemp->gname);
 685         EVP_PKEY *privatekey = NULL;
 686         result = certsvc_pkcs12_dup_evp_pkey_from_store(instance, VPN_STORE, gname, &privatekey);
 687         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting duplicate private key from store failed.");
 688         certsvc_string_free(gname);
 689
 690         FILE *fp = NULL;
 691         if (!(fp = fopen(privatekey_path, "w")))
 692                 RUNNER_ASSERT_MSG(0, "Failed to open file for writing.");
 693
 694         result = PEM_write_PrivateKey(fp, privatekey, NULL, NULL, 0, NULL, NULL);
 695         fclose(fp);
 696         unlink(privatekey_path);
 697
 698         RUNNER_ASSERT_MSG(result != 0, "Failed to write private key onto file.");
 699
 700         certsvc_pkcs12_free_evp_pkey(privatekey);
 701
 702         FREE_INSTANCE
 703 }
 704
 705 RUNNER_TEST(CERTSVC_PKCS12_1019_check_alias_exists)
 706 {
 707         int result;
 708
 709         CREATE_INSTANCE
 710
 711         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer-without-password");
 712
 713         int isUnique = 0;
 714         result = certsvc_pkcs12_check_alias_exists_in_store(instance, allStoreType, Alias, &isUnique);
 715         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from all store failed.");
 716
 717         certsvc_string_free(Alias);
 718
 719         FREE_INSTANCE
 720 }
 721
 722 RUNNER_TEST(CERTSVC_PKCS12_1020_certsvc_set_cert_to_disabled_and_get_status_for_individual_store)
 723 {
 724         CertStoreType storeTypeArr[3] = {VPN_STORE, WIFI_STORE, EMAIL_STORE};
 725         int result;
 726
 727         CREATE_INSTANCE
 728
 729         for (size_t j = 0; j < 3; j++) {
 730                 CertStoreType storeType = storeTypeArr[j];
 731
 732                 CertSvcStoreCertList *certList = NULL;
 733                 size_t length = 0;
 734                 result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 735                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 736
 737                 CertSvcStoreCertList *certListOrig = certList;
 738                 while (certList) {
 739                         CertSvcString Alias = wrapper_certsvc_string_new(certList->gname);
 740
 741                         CertStatus status;
 742                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
 743                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 744
 745                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, DISABLED);
 746                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 747
 748                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
 749                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 750                         RUNNER_ASSERT_MSG(status == DISABLED, "certificate status should be disabled");
 751
 752                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, ENABLED);
 753                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 754
 755                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
 756                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 757                         RUNNER_ASSERT_MSG(status == ENABLED, "certificate status should be enabled");
 758
 759                         certsvc_string_free(Alias);
 760
 761                         certList = certList->next;
 762                 }
 763
 764                 certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
 765         }
 766
 767         FREE_INSTANCE
 768 }
 769
 770 RUNNER_TEST(CERTSVC_PKCS12_1021_add_pem_file_to_invalid_store)
 771 {
 772         int result;
 773
 774         CREATE_INSTANCE
 775
 776         CertSvcString Alias = wrapper_certsvc_string_new("PFX-WifiServer-one-store");
 777         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/wifi-server.pem");
 778         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 779
 780         result = certsvc_pkcs12_import_from_file_to_store(instance, (CertStoreType)-1, Path, Pass, Alias);
 781         RUNNER_ASSERT_MSG(result == CERTSVC_INVALID_STORE_TYPE, "Importing certifcate should be failed with invalid store type");
 782
 783         result = certsvc_pkcs12_import_from_file_to_store(instance, SYSTEM_STORE, Path, Pass, Alias);
 784         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing PEM file to SYSTEM_STORE should be failed");
 785
 786         result = certsvc_pkcs12_delete_certificate_from_store(instance, SYSTEM_STORE, Alias);
 787         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Deleting certificate from SYSTEM_STORE should be failed");
 788
 789         certsvc_string_free(Alias);
 790         certsvc_string_free(Path);
 791
 792         FREE_INSTANCE
 793 }
 794
 795 RUNNER_TEST(CERTSVC_PKCS12_1022_certsvc_set_cert_to_disabled_and_get_status_for_invalid_store)
 796 {
 797         int result;
 798
 799         CREATE_INSTANCE
 800
 801         CertSvcString Alias = wrapper_certsvc_string_new("eb375c3e.0");
 802
 803         CertStatus status;
 804         result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 805         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status with invalid store type should be failed");
 806
 807         result = certsvc_pkcs12_set_certificate_status_to_store(instance, NONE_STORE, DISABLED, Alias, DISABLED);
 808         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Set certificate status with invalid store type should be failed");
 809
 810         result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 811         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status with invalid store type should be failed");
 812
 813         result = certsvc_pkcs12_set_certificate_status_to_store(instance, NONE_STORE, DISABLED, Alias, ENABLED);
 814         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Set certificate status with invalid store type should be failed");
 815
 816         result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 817         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status with invalid store type should be failed");
 818
 819         certsvc_string_free(Alias);
 820
 821         FREE_INSTANCE
 822 }
 823
 824 RUNNER_TEST(CERTSVC_PKCS12_1023_certsvc_set_cert_to_disabled_and_get_status_for_invalid_store)
 825 {
 826         CREATE_INSTANCE
 827
 828         CertSvcStoreCertList *certList = NULL;
 829         size_t length = 0;
 830         int result = certsvc_pkcs12_get_certificate_list_from_store(instance, NONE_STORE, DISABLED, &certList, &length);
 831         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Getting certificate list from invalid store should be failed");
 832         RUNNER_ASSERT_MSG((length == 0 && certList == NULL), "no output should be returned with invalid store");
 833
 834         FREE_INSTANCE
 835 }
 836
 837 RUNNER_TEST(CERTSVC_PKCS12_1024_certsvc_set_and_get_for_invalid_store)
 838 {
 839         int result;
 840
 841         CREATE_INSTANCE
 842
 843         CertSvcString Alias = wrapper_certsvc_string_new("TestingCRT1");
 844         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/Invalidcrt.crt");
 845         CertSvcString Pass = wrapper_certsvc_string_new(NULL);
 846
 847         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 848         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid CRT file should be failed.");
 849
 850         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 851         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid CRT file should be failed.");
 852
 853         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 854         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid CRT file should be failed.");
 855
 856         result = certsvc_pkcs12_import_from_file_to_store(instance, NONE_STORE, Path, Pass, Alias);
 857         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid CRT file should be failed.");
 858
 859         certsvc_string_free(Alias);
 860         certsvc_string_free(Path);
 861
 862         FREE_INSTANCE
 863 }
 864
 865 RUNNER_TEST(CERTSVC_PKCS12_1025_install_invalid_pfx_file_to_individual_and_all_store)
 866 {
 867         int result;
 868
 869         CREATE_INSTANCE
 870
 871         CertSvcString Alias = wrapper_certsvc_string_new("WifiServer-123");
 872         CertSvcString Path = wrapper_certsvc_string_new("/usr/share/cert-svc/tests/test.pfx");
 873         CertSvcString Pass = wrapper_certsvc_string_new("wifi");
 874
 875         result = certsvc_pkcs12_import_from_file_to_store(instance, SYSTEM_STORE, Path, Pass, Alias);
 876         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid PFX file should be failed.");
 877
 878         result = certsvc_pkcs12_import_from_file_to_store(instance, WIFI_STORE, Path, Pass, Alias);
 879         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid PFX file should be failed.");
 880
 881         result = certsvc_pkcs12_import_from_file_to_store(instance, VPN_STORE, Path, Pass, Alias);
 882         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid PFX file should be failed.");
 883
 884         result = certsvc_pkcs12_import_from_file_to_store(instance, EMAIL_STORE, Path, Pass, Alias);
 885         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid PFX file should be failed.");
 886
 887         result = certsvc_pkcs12_import_from_file_to_store(instance, allStoreType, Path, Pass, Alias);
 888         RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Importing invalid PFX file should be failed.");
 889
 890         certsvc_string_free(Alias);
 891         certsvc_string_free(Path);
 892         certsvc_string_free(Pass);
 893
 894         FREE_INSTANCE
 895 }
 896
 897 RUNNER_TEST(CERTSVC_PKCS12_1026_enable_disable_status_certificate_from_invalid_store)
 898 {
 899         int result;
 900
 901         CREATE_INSTANCE
 902
 903         CertSvcStoreCertList *certList = NULL;
 904         size_t length = 0;
 905         result = certsvc_pkcs12_get_certificate_list_from_store(instance, WIFI_STORE, DISABLED, &certList, &length);
 906         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 907         if (length == 0 || !certList) {
 908                 /* TODO: add any cert to store for testing */
 909                 RUNNER_ASSERT_MSG(0, "add any cert in store for testing");
 910         }
 911
 912         while (certList) {
 913                 CertSvcString Alias = wrapper_certsvc_string_new(certList->gname);
 914
 915                 CertStatus status;
 916                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 917                 RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status from invalid store should be failed.");
 918
 919                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, NONE_STORE, DISABLED, Alias, DISABLED);
 920                 RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Set certificate status to invalid store should be failed.");
 921
 922                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 923                 RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status from invalid store should be failed.");
 924
 925                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, NONE_STORE, DISABLED, Alias, ENABLED);
 926                 RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Set certificate status to invalid store should be failed.");
 927
 928                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, NONE_STORE, Alias, &status);
 929                 RUNNER_ASSERT_MSG(result != CERTSVC_SUCCESS, "Get certificate status from invalid store should be failed.");
 930
 931                 certsvc_string_free(Alias);
 932
 933                 certList = certList->next;
 934         }
 935
 936         FREE_INSTANCE
 937 }
 938
 939 #define EAP_TLS_USER_CERT_PATH   "user_cert.pem"
 940 #define EAP_TLS_PATH                     "/tmp/"
 941 #define EAP_TLS_CA_CERT_PATH     "ca_cert.pem"
 942 #define EAP_TLS_PRIVATEKEY_PATH  "privatekey.pem"
 943
 944 RUNNER_TEST(CERTSVC_PKCS12_1027_get_alias_name_from_gname_from_store)
 945 {
 946         int result;
 947
 948         CREATE_INSTANCE
 949
 950         CertSvcStoreCertList *certList = NULL;
 951         size_t length = 0;
 952         result = certsvc_pkcs12_get_certificate_list_from_store(instance, WIFI_STORE, DISABLED, &certList, &length);
 953         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list failed.");
 954
 955         int count = 1;
 956         while (certList) {
 957                 CertSvcString Alias = wrapper_certsvc_string_new(certList->gname);
 958
 959                 char *alias = NULL;
 960                 result = certsvc_pkcs12_get_alias_name_for_certificate_in_store(instance, certList->storeType, Alias, &alias);
 961                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting alias name from gname failed.");
 962
 963                 CertSvcCertificateList cert_list;
 964                 result = certsvc_pkcs12_load_certificate_list_from_store(instance, certList->storeType, Alias, &cert_list);
 965                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_pkcs12_load_certificate_list failed");
 966
 967                 size_t cert_counts = 0;
 968                 result = certsvc_certificate_list_get_length(cert_list, &cert_counts);
 969                 RUNNER_ASSERT_MSG(cert_counts > 0, "there is no certificates");
 970
 971                 CertSvcCertificate *selected_certificate = new CertSvcCertificate[cert_counts];
 972                 RUNNER_ASSERT_MSG(selected_certificate != NULL, "failed to allocate memory");
 973
 974                 CertSvcCertificate user_certificate;
 975                 result = certsvc_certificate_list_get_one(cert_list, 0, &user_certificate);
 976                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_certificate_list_get_one failed");
 977
 978                 X509 *x509 = NULL;
 979                 result = certsvc_certificate_dup_x509(user_certificate, &x509);
 980
 981                 char user_cert_path[512];
 982                 sprintf(user_cert_path, "/usr/share/cert-svc/pkcs12/file_%d", count++);
 983                 FILE *fp = fopen(user_cert_path, "w");
 984                 RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
 985
 986                 if (count == 5)
 987                         break;
 988
 989                 result = PEM_write_X509(fp, x509);
 990                 fclose(fp);
 991
 992                 certsvc_certificate_free_x509(x509);
 993                 certList = certList->next;
 994
 995                 int cert_index = cert_counts - 1;
 996                 selected_certificate[0] = user_certificate;
 997
 998                 char ca_cert_path[512];
 999                 sprintf(ca_cert_path, "%s%s_%s", EAP_TLS_PATH, certList->gname, EAP_TLS_CA_CERT_PATH);
1000                 while (cert_index) {
1001                         CertSvcCertificate ca_certificate;
1002                         result = certsvc_certificate_list_get_one(cert_list, cert_index, &ca_certificate);
1003                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to certsvc_certificate_list_get_one");
1004
1005                         selected_certificate[cert_counts-cert_index] = ca_certificate;
1006                         cert_index--;
1007
1008                         result = certsvc_certificate_dup_x509(ca_certificate, &x509);
1009
1010                         fp = fopen(ca_cert_path, "a");
1011                         RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
1012
1013                         result = PEM_write_X509(fp, x509);
1014                         fclose(fp);
1015
1016                         certsvc_certificate_free_x509(x509);
1017                 }
1018
1019                 int validity = 0;
1020                 result = certsvc_certificate_verify(selected_certificate[0], selected_certificate, cert_counts, NULL, 0, &validity);
1021                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to verify ca_certificate");
1022                 RUNNER_ASSERT_MSG(validity != 0, "Invalid certificate");
1023
1024                 EVP_PKEY *privatekey = NULL;
1025                 result = certsvc_pkcs12_dup_evp_pkey_from_store(instance, WIFI_STORE, Alias, &privatekey);
1026                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Failed to duplicate the private key for a certificate from wifi store");
1027
1028                 char privatekey_path[512];
1029                 sprintf(privatekey_path, "%s%s_%s", EAP_TLS_PATH, certList->gname, EAP_TLS_PRIVATEKEY_PATH);
1030                 fp = fopen(privatekey_path, "w");
1031                 RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
1032
1033                 result = PEM_write_PrivateKey(fp, privatekey, NULL, NULL, 0, NULL, NULL);
1034                 fclose(fp);
1035
1036                 certsvc_pkcs12_free_evp_pkey(privatekey);
1037
1038                 certsvc_string_free(Alias);
1039                 delete []selected_certificate;
1040         }
1041
1042         FREE_INSTANCE
1043 }
1044
1045 RUNNER_TEST(CERTSVC_PKCS12_1028_certsvc_set_cert_to_disabled_and_get_status_for_individual_store)
1046 {
1047         CertStoreType array[3] = {VPN_STORE, WIFI_STORE, EMAIL_STORE};
1048         int result;
1049
1050         CREATE_INSTANCE
1051
1052         for (size_t j = 0; j < 3; j++) {
1053                 CertStoreType storeType = array[j];
1054
1055                 CertSvcStoreCertList *certList = NULL;
1056                 size_t length = 0;
1057                 result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, ENABLED, &certList, &length);
1058                 RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Getting certificate list failed.");
1059
1060                 CertSvcStoreCertList *certListOrig = certList;
1061                 while (certList) {
1062                         CertSvcString Alias = wrapper_certsvc_string_new(certList->gname);
1063
1064                         CertStatus status;
1065                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1066                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from store failed.");
1067
1068                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, ENABLED, Alias, DISABLED);
1069                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to store failed.");
1070
1071                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1072                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from store failed.");
1073
1074                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, ENABLED, Alias, ENABLED);
1075                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Set certificate status to store failed.");
1076
1077                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1078                         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "Get certificate status from store failed.");
1079
1080                         certsvc_string_free(Alias);
1081
1082                         certList = certList->next;
1083                 }
1084
1085                 certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certListOrig);
1086         }
1087
1088         FREE_INSTANCE
1089 }