tests/pkcs12/new_test_cases.cpp

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