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  * @version     1.0
  20  * @brief       PKCS#12 test cases.
  21  */
  22
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <sys/types.h>
  27 #include <sys/wait.h>
  28 #include <dpl/test/test_runner.h>
  29 #include <cert-svc/cinstance.h>
  30 #include <cert-svc/ccert.h>
  31 #include <cert-svc/cpkcs12.h>
  32 #include <cert-svc/cerror.h>
  33 #include <cert-svc/cprimitives.h>
  34 #include <cert-service.h>
  35 #include <cert-service-debug.h>
  36 #include <openssl/err.h>
  37 #include <openssl/pkcs12.h>
  38 #include <openssl/sha.h>
  39 #include <openssl/x509.h>
  40 #include <openssl/pem.h>
  41 #include <time.h>
  42
  43 static CertSvcInstance instance;
  44
  45 #define CREATE_INSTANCE                                   \
  46   certsvc_instance_new(&instance);
  47 #define FREE_INSTANCE                                     \
  48   certsvc_instance_free(instance);
  49
  50 /* Getting the certificate list from system_store */
  51 RUNNER_TEST(CERTSVC_PKCS12_1001_certsvc_get_root_cert_list) {
  52
  53         CertStoreType storeType = SYSTEM_STORE;
  54         CertSvcStoreCertList* certList = NULL;
  55         CertSvcStoreCertList* tmpNode = NULL;
  56         int result;
  57         int count = 0;
  58         CREATE_INSTANCE
  59
  60         size_t length = 0;
  61         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
  62         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
  63         if(result == CERTSVC_SUCCESS)
  64         {
  65           tmpNode = certList;
  66           while(tmpNode != NULL)
  67           {
  68                   count++;
  69                   tmpNode = tmpNode->next;
  70           }
  71
  72           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
  73           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
  74         }
  75
  76         FREE_INSTANCE
  77 }
  78
  79 /* Set the status of the certificate to disabled/enabled in system store and get the status */
  80 RUNNER_TEST(CERTSVC_PKCS12_1002_certsvc_set_cert_to_disabled_and_get_status_for_system_store)
  81 {
  82         CertStoreType storeType = SYSTEM_STORE;
  83         CertStatus Status;
  84         CertStatus status;
  85         int result;
  86         CertSvcString Alias;
  87
  88         CREATE_INSTANCE
  89
  90         result = certsvc_string_new(instance, "Certum_Root_CA.pem", strlen("Certum_Root_CA.pem"), &Alias);
  91         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_string_new failed. result : " << result);
  92
  93         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
  94         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
  95
  96         // if status is already disabled, roll it back to enable and go on
  97         if (status == DISABLED) {
  98                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, ENABLED);
  99                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Roll back certificate status to system store failed.");
 100         }
 101
 102         Status=DISABLED;
 103         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
 104         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 105
 106         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
 107         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 108
 109         Status=ENABLED;
 110         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
 111         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to system store failed.");
 112
 113         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
 114         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
 115
 116         certsvc_string_free(Alias);
 117
 118         FREE_INSTANCE
 119 }
 120
 121 /* Install a CRT file to individual stores */
 122 RUNNER_TEST(CERTSVC_PKCS12_1003_add_pem_file_in_individual_store)
 123 {
 124         CertSvcStoreCertList* certList = NULL;
 125         CertSvcStoreCertList* tmpNode = NULL;
 126         CertSvcStoreCertList* tmp = NULL;
 127         CertStoreType type;
 128         int result;
 129         size_t length = 0;
 130         int count = 0;
 131
 132         CertSvcStoreCertList* certList1 = NULL;
 133         CertSvcString buffer1, gname;
 134         CertSvcString buffer2;
 135         const char *temp = NULL;
 136         CertSvcCertificate certificate;
 137
 138         CertSvcString Alias;
 139         CertSvcString Path;
 140         CertSvcString Pass;
 141
 142         CREATE_INSTANCE
 143
 144         Pass.privateHandler = NULL;
 145
 146         const char *path = "/usr/share/cert-svc/tests/wifi-server.pem";
 147         result = certsvc_string_new(instance, path, strlen(path), &Path);
 148         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_string_new failed. result : " << result);
 149
 150         type = WIFI_STORE;
 151         const char *cAlias = "PEM-wifi-server-1";
 152         result = certsvc_string_new(instance, cAlias, strlen(cAlias), &Alias);
 153         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_string_new failed. result : " << result);
 154
 155         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 156         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PEM file to WIFI store failed.");
 157         certsvc_string_free(Alias);
 158
 159         type = VPN_STORE;
 160         cAlias = "PEM-wifi-server-2";
 161         result = certsvc_string_new(instance, cAlias, strlen(cAlias), &Alias);
 162         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_string_new failed. result : " << result);
 163         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 164         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PEM file to VPN store failed.");
 165         certsvc_string_free(Alias);
 166
 167         type = EMAIL_STORE;
 168         cAlias = "PEM-wifi-server-3";
 169         result = certsvc_string_new(instance, cAlias, strlen(cAlias), &Alias);
 170         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_string_new failed. result : " << result);
 171
 172         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 173         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PEM file to EMAIL store failed.");
 174         certsvc_string_free(Alias);
 175
 176         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 177         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 178         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 179
 180         if(result == CERTSVC_SUCCESS)
 181         {
 182
 183           tmpNode = certList;
 184           while(tmpNode != NULL)
 185           {
 186                   count++;
 187                   tmp = tmpNode;
 188                   tmpNode = tmpNode->next;
 189           }
 190           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 191           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 192
 193         }
 194
 195         certList = NULL;
 196         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 197         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 198         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 199         certList1=certList;
 200         count = 0;
 201         while (certList) {
 202                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 203                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 204
 205                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &buffer1);
 206                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 207
 208                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &buffer2);
 209                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 210
 211                 certsvc_string_to_cstring(buffer1, &temp, &length);
 212                 certsvc_string_to_cstring(buffer2, &temp, &length);
 213
 214                 certsvc_string_free(buffer1);
 215                 certsvc_string_free(buffer2);
 216                 certsvc_certificate_free(certificate);
 217                 certList = certList->next;
 218                 count++;
 219         }
 220         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList1);
 221         if (certList1 != NULL)
 222
 223         certList=NULL;
 224         certList1=NULL;
 225
 226         certsvc_string_free(Path);
 227
 228         FREE_INSTANCE
 229 }
 230
 231 /* Installing pem file in all store at once */
 232 RUNNER_TEST(CERTSVC_PKCS12_1004_add_pem_file_in_all_store) {
 233
 234         const char path[] = "/usr/share/cert-svc/tests/wifi-server.pem";
 235         CertSvcStoreCertList* certList = NULL;
 236         CertSvcStoreCertList* tmpNode = NULL;
 237         CertSvcStoreCertList* tmp = NULL;
 238         char* pass = NULL;
 239         char *alias = "PEM-wifi-server-all-store";
 240         CertStoreType type;
 241         int result;
 242         int count = 0;
 243         size_t length = 0;
 244
 245         CREATE_INSTANCE
 246         CertSvcString Alias, Path, Pass;
 247
 248         Alias.privateHandler = alias;
 249         Alias.privateLength = strlen(alias);
 250         Pass.privateHandler = pass;
 251         Path.privateHandler = (char *)path;
 252         Path.privateLength = strlen(path);
 253
 254         type = (CertStoreType) (VPN_STORE | EMAIL_STORE | WIFI_STORE);
 255         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 256         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PEM file to all store failed.");
 257
 258         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 259         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 260         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 261
 262         if(result == CERTSVC_SUCCESS)
 263         {
 264           tmpNode = certList;
 265           while(tmpNode != NULL)
 266           {
 267                   count++;
 268                   tmp = tmpNode;
 269                   tmpNode = tmpNode->next;
 270           }
 271           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 272           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 273         }
 274
 275         FREE_INSTANCE
 276 }
 277
 278 /* Install a CRT file to individual stores */
 279 RUNNER_TEST(CERTSVC_PKCS12_1005_add_crt_file_in_individual_store) {
 280
 281         const char path[] = "/usr/share/cert-svc/tests/Testing.crt";
 282         CertSvcStoreCertList* certList = NULL;
 283         CertSvcStoreCertList* tmpNode = NULL;
 284         CertSvcStoreCertList* tmp = NULL;
 285         char* pass = NULL;
 286         char *alias = "CRT-TestingCRT1";
 287         CertStoreType type;
 288         int result;
 289         size_t length = 0;
 290         int count = 0;
 291
 292         CertSvcStoreCertList* certList1 = NULL;
 293         CertSvcString buffer1, gname;
 294         CertSvcString buffer2;
 295         const char *temp = NULL;
 296         CertSvcCertificate certificate;
 297
 298         CREATE_INSTANCE
 299         CertSvcString Alias, Path, Pass;
 300
 301         Alias.privateHandler = alias;
 302         Alias.privateLength = strlen(alias);
 303         Pass.privateHandler = pass;
 304         Path.privateHandler = (char *)path;
 305         Path.privateLength = strlen(path);
 306
 307         type = WIFI_STORE;
 308         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 309         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing CRT file to WIFI store failed.");
 310
 311         type = VPN_STORE;
 312         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 313         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing CRT file to VPN store failed.");
 314
 315         type = EMAIL_STORE;
 316         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 317         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing CRT file to EMAIL store failed.");
 318
 319         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 320         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 321         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 322
 323         if(result == CERTSVC_SUCCESS)
 324         {
 325           tmpNode = certList;
 326           while(tmpNode != NULL)
 327           {
 328                   count++;
 329                   tmp = tmpNode;
 330                   tmpNode = tmpNode->next;
 331           }
 332           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 333           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 334         }
 335
 336         certList = NULL;
 337         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 338         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 339         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 340         certList1=certList;
 341         count = 0;
 342         while(certList!=NULL)
 343         {
 344                 gname.privateHandler = (char *)certList->gname;
 345                 gname.privateLength = strlen(certList->gname);
 346                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 347                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 348
 349                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &buffer1);
 350                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 351
 352                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &buffer2);
 353                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 354
 355                 certsvc_string_to_cstring(buffer1, &temp, &length);
 356                 certsvc_string_to_cstring(buffer2, &temp, &length);
 357
 358                 certsvc_string_free(buffer1);
 359                 certsvc_string_free(buffer2);
 360                 certsvc_certificate_free(certificate);
 361                 certList = certList->next;
 362                 count++;
 363         }
 364         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList1);
 365         certList=NULL;
 366         certList1=NULL;
 367
 368         FREE_INSTANCE
 369 }
 370
 371 /* Install a CRT file to all store at once */
 372 RUNNER_TEST(CERTSVC_PKCS12_1006_add_crt_file_in_all_store) {
 373
 374         const char path[] = "/usr/share/cert-svc/tests/Testing.crt";
 375         CertSvcStoreCertList* certList = NULL;
 376         CertSvcStoreCertList* tmpNode = NULL;
 377         CertSvcStoreCertList* tmp = NULL;
 378         char* pass = NULL;
 379         char *alias = "CRT-TestingCRT1-all-store";
 380         CertStoreType type;
 381         int result;
 382         int count = 0;
 383         size_t length = 0;
 384
 385         CREATE_INSTANCE
 386         CertSvcString Alias, Path, Pass;
 387
 388         Alias.privateHandler = alias;
 389         Alias.privateLength = strlen(alias);
 390         Pass.privateHandler = pass;
 391         Path.privateHandler = (char *)path;
 392         Path.privateLength = strlen(path);
 393
 394         type = (CertStoreType )(WIFI_STORE | VPN_STORE | EMAIL_STORE);
 395         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
 396         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing CRT file to all store failed.");
 397
 398         type = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 399         result = certsvc_pkcs12_get_certificate_list_from_store(instance, type, DISABLED, &certList, &length);
 400         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 401
 402         if(result == CERTSVC_SUCCESS)
 403         {
 404           tmpNode = certList;
 405           while(tmpNode != NULL)
 406           {
 407                   count++;
 408                   tmp = tmpNode;
 409                   tmpNode = tmpNode->next;
 410           }
 411           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 412           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 413
 414         }
 415
 416         FREE_INSTANCE
 417 }
 418
 419 /* Import a P12 file to individual store */
 420 RUNNER_TEST(CERTSVC_PKCS12_1007_install_p12_file_to_individual_store) {
 421
 422         const char path[] = "/usr/share/cert-svc/tests/wifiuser.p12";
 423         CertSvcStoreCertList* certList = NULL;
 424         CertSvcStoreCertList* tmpNode = NULL;
 425         CertSvcStoreCertList* tmp = NULL;
 426         const char pass[] = "wifi";
 427         char *alias = "P12-WifiUser";
 428         CertStoreType storeType;
 429         int result;
 430         size_t length = 0;
 431         int count = 0;
 432
 433         CREATE_INSTANCE
 434         CertSvcString Alias, Path, Pass;
 435
 436         Alias.privateHandler = (char *)alias;
 437         Alias.privateLength = strlen(alias);
 438         Pass.privateHandler = (char *)pass;
 439         Pass.privateLength = strlen(pass);
 440         Path.privateHandler = (char *)path;
 441         Path.privateLength = strlen(path);
 442
 443 /*
 444         result = certsvc_pkcs12_import_from_file(instance, Path, Pass, Alias);
 445         RUNNER_ASSERT_MSG(result == CERTSVC_SUCCESS, "certsvc_pkcs12_import_from_file failed.");
 446 */
 447
 448         storeType = WIFI_STORE;
 449         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 450         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing p12 file to WIFI store failed.");
 451
 452         storeType = VPN_STORE;
 453         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 454         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing p12 file to VPN store failed.");
 455
 456         storeType = EMAIL_STORE;
 457         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 458         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing p12 file to EMAIL store failed.");
 459
 460         storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 461         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 462         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 463
 464         if(result == CERTSVC_SUCCESS)
 465         {
 466           tmpNode = certList;
 467           while(tmpNode != NULL)
 468           {
 469                   count++;
 470                   tmp = tmpNode;
 471                   tmpNode = tmpNode->next;
 472           }
 473           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 474           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 475         }
 476
 477         FREE_INSTANCE
 478 }
 479
 480 /* Import a P12 file to all store */
 481 RUNNER_TEST(CERTSVC_PKCS12_1008_install_p12_file_to_all_store) {
 482
 483         const char path[] = "/usr/share/cert-svc/tests/wifiuser.p12";
 484         CertSvcStoreCertList* certList = NULL;
 485         CertSvcStoreCertList* tmpNode = NULL;
 486         CertSvcStoreCertList* tmp = NULL;
 487         const char pass[] = "wifi";
 488         char *alias = "P12-WifiUser-all-store";
 489         CertStoreType storeType;
 490         int result;
 491         size_t length = 0;
 492         int count =0;
 493
 494         CREATE_INSTANCE
 495         CertSvcString Alias, Path, Pass;
 496
 497         Alias.privateHandler = (char *)alias;
 498         Alias.privateLength = strlen(alias);
 499         Pass.privateHandler = (char *)pass;
 500         Pass.privateLength = strlen(pass);
 501         Path.privateHandler = (char *)path;
 502         Path.privateLength = strlen(path);
 503
 504         storeType = (CertStoreType )(WIFI_STORE | VPN_STORE | EMAIL_STORE);
 505         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 506         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing p12 file to WIFI store failed.");
 507
 508         storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 509         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 510         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 511
 512         if(result == CERTSVC_SUCCESS)
 513         {
 514           tmpNode = certList;
 515           while(tmpNode != NULL)
 516           {
 517                   count++;
 518                   tmp = tmpNode;
 519                   tmpNode = tmpNode->next;
 520           }
 521           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 522           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 523         }
 524
 525         FREE_INSTANCE
 526 }
 527
 528 /* Import a P12 file to individual store */
 529 RUNNER_TEST(CERTSVC_PKCS12_1009_install_pfx_file_to_individual_store) {
 530
 531         const char path[] = "/usr/share/cert-svc/tests/wifiserver.pfx";
 532         CertSvcStoreCertList* certList = NULL;
 533         CertSvcStoreCertList* tmpNode = NULL;
 534         CertSvcStoreCertList* tmp = NULL;
 535         const char pass[] = "wifi";
 536         char *alias = "PFX-WifiServer";
 537         CertStoreType storeType;
 538         int result;
 539         int count = 0;
 540         size_t length = 0;
 541
 542         CREATE_INSTANCE
 543         CertSvcString Alias, Path, Pass;
 544
 545         Alias.privateHandler = (char *)alias;
 546         Alias.privateLength = strlen(alias);
 547         Pass.privateHandler = (char *)pass;
 548         Pass.privateLength = strlen(pass);
 549         Path.privateHandler = (char *)path;
 550         Path.privateLength = strlen(path);
 551
 552         storeType = WIFI_STORE;
 553         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 554         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 555
 556         storeType = VPN_STORE;
 557         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 558         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to VPN store failed.");
 559
 560         storeType = EMAIL_STORE;
 561         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 562         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to EMAIL store failed.");
 563
 564         storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 565         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 566         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 567
 568         if(result == CERTSVC_SUCCESS)
 569         {
 570           tmpNode = certList;
 571           while(tmpNode != NULL)
 572           {
 573                   count++;
 574                   tmp = tmpNode;
 575                   tmpNode = tmpNode->next;
 576           }
 577           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 578           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 579         }
 580
 581         FREE_INSTANCE
 582 }
 583
 584 RUNNER_TEST(CERTSVC_PKCS12_1010_install_pfx_file_to_all_store) {
 585
 586         const char path[] = "/usr/share/cert-svc/tests/wifiserver.pfx";
 587         const char pass[] = "wifi";
 588         char *alias = "PFX-WifiServer-all-store";
 589         CertStoreType storeType;
 590         CertSvcStoreCertList* certList = NULL;
 591         CertSvcStoreCertList* tmpNode = NULL;
 592         CertSvcStoreCertList* tmp = NULL;
 593         size_t length = 0;
 594         int count = 0;
 595         int result;
 596
 597         CREATE_INSTANCE
 598         CertSvcString Alias, Path, Pass;
 599
 600         Alias.privateHandler = (char *)alias;
 601         Alias.privateLength = strlen(alias);
 602         Pass.privateHandler = (char *)pass;
 603         Pass.privateLength = strlen(pass);
 604         Path.privateHandler = (char *)path;
 605         Path.privateLength = strlen(path);
 606
 607         storeType = (CertStoreType) (VPN_STORE | EMAIL_STORE | WIFI_STORE);
 608         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 609         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 610
 611         storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 612         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 613         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 614
 615         if(result == CERTSVC_SUCCESS)
 616         {
 617
 618           tmpNode = certList;
 619           while(tmpNode != NULL)
 620           {
 621                   count++;
 622                   tmp = tmpNode;
 623                   tmpNode = tmpNode->next;
 624           }
 625           result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 626           RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 627         }
 628
 629         FREE_INSTANCE
 630 }
 631
 632 /* Getting all end user & root certificate list from WIFI,VPN,EMAIL store */
 633 RUNNER_TEST(CERTSVC_PKCS12_1011_get_all_end_user_certificate_from_store) {
 634
 635         CertSvcStoreCertList* certList = NULL;
 636         CertSvcStoreCertList* tmpNode = NULL;
 637         CertStoreType storeType = (CertStoreType) (WIFI_STORE);
 638         int result;
 639         size_t length;
 640
 641         CREATE_INSTANCE
 642
 643         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, storeType, &certList, &length);
 644         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 645         tmpNode=certList;
 646         while(tmpNode!=NULL)
 647         {
 648                 tmpNode = tmpNode->next;
 649         }
 650         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 651         certList = NULL;
 652         tmpNode = NULL;
 653
 654         storeType = (CertStoreType) (VPN_STORE);
 655         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, storeType, &certList, &length);
 656         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 657         tmpNode=certList;
 658         while(tmpNode!=NULL)
 659         {
 660                 tmpNode = tmpNode->next;
 661         }
 662         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 663         certList = NULL;
 664         tmpNode = NULL;
 665
 666         storeType = (CertStoreType) (EMAIL_STORE);
 667         result = certsvc_pkcs12_get_end_user_certificate_list_from_store(instance, storeType, &certList, &length);
 668         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 669         tmpNode=certList;
 670         while(tmpNode!=NULL)
 671         {
 672                 tmpNode = tmpNode->next;
 673         }
 674         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 675         certList = NULL;
 676         tmpNode = NULL;
 677
 678         storeType = (CertStoreType) (WIFI_STORE);
 679         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, storeType, &certList, &length);
 680         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 681         tmpNode=certList;
 682         while(tmpNode!=NULL)
 683         {
 684                 tmpNode = tmpNode->next;
 685         }
 686         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 687         certList = NULL;
 688         tmpNode = NULL;
 689
 690         storeType = (CertStoreType) (VPN_STORE);
 691         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, storeType, &certList, &length);
 692         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 693         tmpNode=certList;
 694         while(tmpNode!=NULL)
 695         {
 696                 tmpNode = tmpNode->next;
 697         }
 698         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 699         certList = NULL;
 700         tmpNode = NULL;
 701
 702         storeType = (CertStoreType) (EMAIL_STORE);
 703         result = certsvc_pkcs12_get_root_certificate_list_from_store(instance, storeType, &certList, &length);
 704         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting end user certificate list from store failed.");
 705         tmpNode=certList;
 706         while(tmpNode!=NULL)
 707         {
 708                 tmpNode = tmpNode->next;
 709         }
 710         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 711         certList = NULL;
 712         tmpNode = NULL;
 713
 714         FREE_INSTANCE
 715 }
 716
 717 /* Delete all certificate from WIFI,VPN,EMAIL store */
 718 RUNNER_TEST(CERTSVC_PKCS12_1012_delete_all_cert_from_multiple_store) {
 719
 720         CertSvcStoreCertList* certList = NULL;
 721         CertSvcStoreCertList* certList1 = NULL;
 722         CertStoreType storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 723         int result;
 724         size_t length;
 725         CertSvcString gname;
 726
 727         CREATE_INSTANCE
 728
 729         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 730         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 731         certList1=certList;
 732         while(certList1!=NULL)
 733         {
 734                 gname.privateHandler = (char *)certList1->gname;
 735                 gname.privateLength = strlen(certList1->gname);
 736                 result = certsvc_pkcs12_delete_certificate_from_store(instance, (CertStoreType) certList1->storeType, gname);
 737                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Deleting certificate from store failed.");
 738                 certList1 = certList1->next;
 739         }
 740         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 741         certList=NULL;
 742
 743         FREE_INSTANCE
 744 }
 745
 746 /* Import the file to one store and try to get the certlist from all store */
 747 RUNNER_TEST(CERTSVC_PKCS12_1013_install_pfx_file_to_one_store_and_get_list_from_multiple_store) {
 748
 749         const char path[] = "/usr/share/cert-svc/tests/wifiserver.pfx";
 750         const char pass[] = "wifi";
 751         char *alias = "PFX-WifiServer-one-store";
 752         CertStoreType storeType;
 753         CertSvcStoreCertList* certList = NULL;
 754         CertSvcStoreCertList* tmpNode = NULL;
 755         CertSvcStoreCertList* tmp = NULL;
 756         size_t length = 0;
 757         int count = 0;
 758         int result = -1;
 759         gboolean exists = FALSE;
 760
 761         CREATE_INSTANCE
 762         CertSvcString Alias, Path, Pass;
 763
 764         Alias.privateHandler = (char *)alias;
 765         Alias.privateLength = strlen(alias);
 766         Pass.privateHandler = (char *)pass;
 767         Pass.privateLength = strlen(pass);
 768         Path.privateHandler = (char *)path;
 769         Path.privateLength = strlen(path);
 770
 771         storeType = (CertStoreType) (VPN_STORE | WIFI_STORE | EMAIL_STORE);
 772         result = certsvc_pkcs12_check_alias_exists_in_store(instance, storeType, Alias, &exists);
 773         if (exists==TRUE) {
 774                 /* installing the pfx in one store and getting the list from multiple store */
 775                 storeType = (CertStoreType) ( EMAIL_STORE );
 776                 result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 777                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 778
 779                 storeType = (CertStoreType) ( VPN_STORE | WIFI_STORE  );
 780                 result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 781                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 782
 783                 storeType = (CertStoreType) ( VPN_STORE | WIFI_STORE | EMAIL_STORE);
 784                 result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 785                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from system store failed");
 786
 787                 if(result == CERTSVC_SUCCESS)
 788                 {
 789                   tmpNode = certList;
 790                   while(tmpNode != NULL)
 791                   {
 792                           count++;
 793                           tmp = tmpNode;
 794                           tmpNode = tmpNode->next;
 795                   }
 796                   result = certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList);
 797                   RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Freeing certificate list from system store failed");
 798                 }
 799         }
 800
 801         FREE_INSTANCE
 802 }
 803
 804 /* Set the status of the certificate to disabled and trying to delete store */
 805 RUNNER_TEST(CERTSVC_PKCS12_1014_installing_pfx_without_password_to_individual_store) {
 806
 807         const char path[] = "/usr/share/cert-svc/tests/without_pass.p12";
 808         const char pass[] = "";
 809         char *alias = "PFX-WifiServer-without-password";
 810         CertStoreType storeType;
 811         int result;
 812         int exists;
 813
 814         CREATE_INSTANCE
 815         CertSvcString Alias, Path, Pass;
 816
 817         Alias.privateHandler = (char *)alias;
 818         Alias.privateLength = strlen(alias);
 819         Pass.privateHandler = (char *)pass;
 820         Pass.privateLength = strlen(pass);
 821         Path.privateHandler = (char *)path;
 822         Path.privateLength = strlen(path);
 823
 824         storeType = (CertStoreType) (VPN_STORE | WIFI_STORE | EMAIL_STORE);
 825         result = certsvc_pkcs12_check_alias_exists_in_store(instance, storeType, Alias, &exists);
 826         if (exists==TRUE) {
 827                 storeType = (CertStoreType) (VPN_STORE | WIFI_STORE | EMAIL_STORE);
 828                 result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
 829                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
 830         }
 831
 832         FREE_INSTANCE
 833 }
 834
 835 /* Get certificate from WIFI,VPN,EMAIL store */
 836 RUNNER_TEST(CERTSVC_PKCS12_1015_get_certificate_from_store) {
 837
 838         CertSvcStoreCertList* certList = NULL;
 839         CertSvcStoreCertList* certList1 = NULL;
 840         CertStoreType storeType = (CertStoreType) (WIFI_STORE | VPN_STORE | EMAIL_STORE);
 841         int result;
 842         size_t length;
 843         CertSvcString buffer1, gname;
 844         CertSvcString buffer2;
 845         const char *temp = NULL;
 846         CertSvcCertificate certificate;
 847
 848         CREATE_INSTANCE
 849
 850         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 851         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 852         certList1=certList;
 853         while(certList!=NULL)
 854         {
 855                 gname.privateHandler = (char *)certList->gname;
 856                 gname.privateLength = strlen(certList->gname);
 857                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 858                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 859
 860                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &buffer1);
 861                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 862
 863                 certsvc_string_to_cstring(buffer1, &temp, &length);
 864
 865                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &buffer2);
 866                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 867
 868                 certsvc_string_to_cstring(buffer2, &temp, &length);
 869
 870                 certsvc_string_free(buffer1);
 871                 certsvc_string_free(buffer2);
 872                 certsvc_certificate_free(certificate);
 873                 certList = certList->next;
 874         }
 875         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList1);
 876         certList=NULL;
 877         certList1=NULL;
 878
 879         FREE_INSTANCE
 880 }
 881
 882 /* Get certificate from system store */
 883 RUNNER_TEST(CERTSVC_PKCS12_1016_get_certificate_from_system_store) {
 884
 885         CertSvcStoreCertList* certList = NULL;
 886         CertSvcStoreCertList* certList1 = NULL;
 887         CertStoreType storeType = (CertStoreType) (SYSTEM_STORE);
 888         int result = CERTSVC_SUCCESS;
 889         size_t length = 0;
 890         int count = 0;
 891         CertSvcString buffer1, gname;
 892         CertSvcString buffer2;
 893         const char *temp = NULL;
 894         CertSvcCertificate certificate;
 895
 896         CREATE_INSTANCE
 897
 898         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
 899         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 900         certList1=certList;
 901         while(certList!=NULL)
 902         {
 903                 gname.privateHandler = (char *)certList->gname;
 904                 gname.privateLength = strlen(certList->gname);
 905                 result = certsvc_pkcs12_get_certificate_from_store(instance, certList->storeType, certList->gname, &certificate);
 906                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get certificate from store.");
 907
 908                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_SUBJECT, &buffer1);
 909                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 910
 911                 result = certsvc_certificate_get_string_field(certificate, CERTSVC_ISSUER_COMMON_NAME, &buffer2);
 912                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 913
 914                 certsvc_string_to_cstring(buffer1, &temp, &length);
 915                 certsvc_string_to_cstring(buffer2, &temp, &length);
 916
 917                 certsvc_string_free(buffer1);
 918                 certsvc_string_free(buffer2);
 919                 certsvc_certificate_free(certificate);
 920                 certList = certList->next;
 921                 count++;
 922         }
 923         certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &certList1);
 924
 925         certList=NULL;
 926         certList1=NULL;
 927
 928         FREE_INSTANCE
 929 }
 930
 931 /* Load certificate list form store for a certificate */
 932 RUNNER_TEST(CERTSVC_PKCS12_1017_load_cert_list_from_store) {
 933
 934         CertStoreType storeType;
 935         CertSvcCertificateList certList;
 936         CertSvcStoreCertList* certList1 = NULL;
 937         CertSvcCertificate cert;
 938         int result = CERTSVC_SUCCESS;
 939         size_t length = 0;
 940         int i=0;
 941         size_t certListlength = 0;
 942         const char *temp = NULL;
 943         CertSvcString buffer1,buffer2, gname;
 944
 945         CREATE_INSTANCE
 946
 947         storeType = (CertStoreType) (VPN_STORE);
 948         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList1, &length);
 949         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 950         while(certList1!=NULL)
 951         {
 952                 gname.privateHandler = (char *)certList1->gname;
 953                 gname.privateLength = strlen(certList1->gname);
 954
 955                 result = certsvc_pkcs12_load_certificate_list_from_store(instance, storeType, gname, &certList);
 956                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Load certificate list form store failed.");
 957
 958                 result = certsvc_certificate_list_get_length(certList, &certListlength);
 959                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate list get length failed.");
 960
 961                 for(i=0; i<certListlength; i++)
 962                 {
 963                         result = certsvc_certificate_list_get_one(certList, i, &cert);
 964                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "certsvc_certificate_list_get_one returned not CERTSVC_SUCCESS");
 965
 966                         result = certsvc_certificate_get_string_field(cert, CERTSVC_SUBJECT, &buffer1);
 967                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 968
 969                         certsvc_string_to_cstring(buffer1, &temp, &length);
 970
 971                         result = certsvc_certificate_get_string_field(cert, CERTSVC_ISSUER_COMMON_NAME, &buffer2);
 972                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to get string field.");
 973
 974                         certsvc_string_to_cstring(buffer2, &temp, &length);
 975                 }
 976                 break; // Should run for only one time //
 977         }
 978
 979         FREE_INSTANCE
 980 }
 981
 982 /* Load certificate list form store for a certificate */
 983 RUNNER_TEST(CERTSVC_PKCS12_1018_get_duplicate_private_key) {
 984
 985         CertStoreType storeType;
 986         CertSvcStoreCertList* certList1 = NULL;
 987         FILE *fp = NULL;
 988         int result = CERTSVC_SUCCESS;
 989         size_t length = 0;
 990         CertSvcString gname;
 991         const char *privatekey_path = "/usr/share/cert-svc/pkcs12/temp.txt";
 992         EVP_PKEY *privatekey = NULL;
 993
 994         CREATE_INSTANCE
 995
 996         storeType = (CertStoreType) (VPN_STORE);
 997         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList1, &length);
 998         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
 999         while(certList1!=NULL)
1000         {
1001                 gname.privateHandler = (char *)certList1->gname;
1002                 gname.privateLength = strlen(certList1->gname);
1003                 result = certsvc_pkcs12_dup_evp_pkey_from_store(instance, storeType, gname, &privatekey);
1004                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting duplicate private key from store failed.");
1005
1006                 if ((fp = fopen(privatekey_path, "w")) == NULL) {
1007                         result = CERTSVC_FAIL;
1008                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to open file for writing.");
1009                 }
1010
1011                 result = PEM_write_PrivateKey(fp, privatekey, NULL, NULL, 0, NULL, NULL);
1012                 RUNNER_ASSERT_MSG(result!=0, "Failed to write private key onto file.");
1013                 fclose(fp);
1014
1015                 certsvc_pkcs12_free_evp_pkey(privatekey);
1016
1017                 break; // Should run for only one time //
1018         }
1019
1020         FREE_INSTANCE
1021 }
1022
1023 /* Get certificate from system store */
1024 RUNNER_TEST(CERTSVC_PKCS12_1019_check_alias_exists) {
1025
1026         char *alias = "PFX-WifiServer-without-password";
1027         CertStoreType storeType;
1028         int result = CERTSVC_SUCCESS;
1029         gboolean exists = FALSE;
1030
1031         CREATE_INSTANCE
1032         CertSvcString Alias;
1033
1034         Alias.privateHandler = (char *)alias;
1035         Alias.privateLength = strlen(alias);
1036         storeType = (CertStoreType) (VPN_STORE | WIFI_STORE | EMAIL_STORE);
1037         result = certsvc_pkcs12_check_alias_exists_in_store(instance, storeType, Alias, &exists);
1038         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1039
1040         FREE_INSTANCE
1041 }
1042
1043 /* Set the status of the certificate to disabled/enabled in wifi,vpn,email store */
1044 RUNNER_TEST(CERTSVC_PKCS12_1020_certsvc_set_cert_to_disabled_and_get_status_for_individual_store) {
1045
1046         CertSvcStoreCertList* certList = NULL;
1047         CertSvcStoreCertList* tmpNode = NULL;
1048         int array[3]={VPN_STORE,WIFI_STORE,EMAIL_STORE};
1049         int result = CERTSVC_SUCCESS;
1050         CertSvcString Alias;
1051         CertStatus Status;
1052         CertStatus status;
1053         size_t length = 0;
1054         int count = 0;
1055     int i;
1056
1057         CREATE_INSTANCE
1058
1059         for(int j=0;j<3;j++)
1060         {
1061         i = array[j];
1062
1063                 result = certsvc_pkcs12_get_certificate_list_from_store(instance, (CertStoreType)i, DISABLED, &certList, &length);
1064                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1065                 tmpNode = certList;
1066                 while(certList!=NULL)
1067                 {
1068                         count++;
1069                         Alias.privateHandler = certList->gname;
1070                         Alias.privateLength = strlen((const char*)certList->gname);
1071
1072                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1073                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1074
1075                         Status=DISABLED;
1076                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, DISABLED, Alias, Status);
1077                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1078
1079                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1080                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1081
1082                         Status=ENABLED;
1083                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, DISABLED, Alias, Status);
1084                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1085
1086                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1087                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1088
1089                         certList = certList->next;
1090                 }
1091
1092                 certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &tmpNode);
1093         }
1094
1095         FREE_INSTANCE
1096 }
1097
1098 /* Negative test case */
1099 /* Install a PEM file to invalid store  */
1100 RUNNER_TEST(CERTSVC_PKCS12_1021_add_pem_file_to_invalid_store) {
1101
1102         const char path[] = "/usr/share/cert-svc/tests/wifi-server.pem";
1103         char* pass = NULL;
1104         char *alias = "PFX-WifiServer-one-store";
1105         int result;
1106         CertStoreType storeType = (CertStoreType) (-1);
1107         CertSvcString Alias, Path, Pass;
1108
1109         CREATE_INSTANCE
1110
1111         Alias.privateHandler = alias;
1112         Alias.privateLength = strlen(alias);
1113         Pass.privateHandler = pass;
1114         Path.privateHandler = (char *)path;
1115         Path.privateLength = strlen(path);
1116
1117         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1118         RUNNER_ASSERT_MSG(result==CERTSVC_INVALID_STORE_TYPE, "Importing certifcate with existing alias to WIFI store failed.");
1119
1120         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1121         RUNNER_ASSERT_MSG(result==CERTSVC_INVALID_STORE_TYPE, "Importing certifcate with existing alias to VPN store failed.");
1122
1123         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1124         RUNNER_ASSERT_MSG(result==CERTSVC_INVALID_STORE_TYPE, "Importing certifcate with existing alias to EMAIL store failed.");
1125
1126         /* Installing a PEM certificate to system store should fail */
1127         storeType = SYSTEM_STORE;
1128         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1129         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PEM file to EMAIL store failed.");
1130
1131         /* Removing certificate to system store should fail */
1132         result = certsvc_pkcs12_delete_certificate_from_store(instance, storeType, Alias);
1133         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Deleting certificate from store failed.");
1134
1135
1136         FREE_INSTANCE
1137 }
1138
1139 /* Set the status of the certificate to disabled/enabled from invalid store */
1140 RUNNER_TEST(CERTSVC_PKCS12_1022_certsvc_set_cert_to_disabled_and_get_status_for_invalid_store) {
1141
1142         char* gname = "eb375c3e.0";
1143         CertStoreType storeType = (CertStoreType) (DISABLED);
1144         CertStatus Status;
1145         CertStatus status;
1146         int result;
1147         CertSvcString Alias;
1148
1149         CREATE_INSTANCE
1150
1151         Alias.privateHandler = gname;
1152         Alias.privateLength = strlen((const char*)gname);
1153
1154         /* getting status from a invalid store should fail */
1155         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1156         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1157
1158         /* setting status to a invalid store should fail */
1159         Status=DISABLED;
1160         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
1161         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1162
1163         /* getting status from a invalid store should fail */
1164         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1165         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1166
1167         /* setting status to a invalid store should fail */
1168         Status=ENABLED;
1169         result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
1170         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1171
1172         /* setting status to a invalid store should fail */
1173         result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1174         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1175
1176
1177         FREE_INSTANCE
1178 }
1179
1180 /* Set the status of the certificate to disabled/enabled in wifi,vpn,email store */
1181 RUNNER_TEST(CERTSVC_PKCS12_1023_certsvc_set_cert_to_disabled_and_get_status_for_invalid_store) {
1182
1183         CertStoreType storeType =  (CertStoreType) (0);
1184         CertSvcStoreCertList* certList = NULL;
1185         CertStatus Status;
1186         CertStatus status;
1187         size_t length;
1188         int result;
1189         CertSvcString Alias;
1190
1191         CREATE_INSTANCE
1192
1193         /* Getting certificate list from invalid store should fail */
1194         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
1195         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1196         while(certList!=NULL)
1197         {
1198                 Alias.privateHandler = certList->gname;
1199                 Alias.privateLength = strlen((const char*)certList->gname);
1200
1201                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1202                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1203
1204                 Status=DISABLED;
1205                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
1206                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1207
1208                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1209                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1210
1211                 Status=ENABLED;
1212                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, storeType, DISABLED, Alias, Status);
1213                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1214
1215                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, storeType, Alias, &status);
1216                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1217
1218                 certList = certList->next;
1219         }
1220
1221         FREE_INSTANCE
1222 }
1223
1224 /* Intsalling an invalid crt file to valid store & invalid store*/
1225 RUNNER_TEST(CERTSVC_PKCS12_1024_certsvc_set_and_get_for_invalid_store) {
1226
1227         const char path[] = "/usr/share/cert-svc/tests/Invalidcrt.crt";
1228         char* pass = NULL;
1229         char *alias = "TestingCRT1";
1230         CertStoreType type;
1231         int result;
1232
1233         CREATE_INSTANCE
1234         CertSvcString Alias, Path, Pass;
1235
1236         Alias.privateHandler = alias;
1237         Alias.privateLength = strlen(alias);
1238         Pass.privateHandler = pass;
1239         Path.privateHandler = (char *)path;
1240         Path.privateLength = strlen(path);
1241
1242         /* Installing an invalid CRT file to valid store should fail */
1243         type = WIFI_STORE;
1244         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
1245         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing CRT file to WIFI store failed.");
1246
1247         /* Installing an invalid CRT file to valid store should fail */
1248         type = VPN_STORE;
1249         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
1250         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing CRT file to VPN store failed.");
1251
1252         /* Installing an invalid CRT file to valid store should fail */
1253         type = EMAIL_STORE;
1254         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
1255         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing CRT file to EMAIL store failed.");
1256
1257         /* Installing an invalid CRT file to valid store should fail */
1258         type = (CertStoreType) 0;
1259         result = certsvc_pkcs12_import_from_file_to_store(instance, type, Path, Pass, Alias);
1260         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing CRT file to EMAIL store failed.");
1261
1262         FREE_INSTANCE
1263 }
1264
1265 /* Import a invalid P12 file to individual and all store */
1266 RUNNER_TEST(CERTSVC_PKCS12_1025_install_invalid_pfx_file_to_individual_and_all_store) {
1267
1268         const char path[] = "/usr/share/cert-svc/tests/test.pfx";
1269         const char pass[] = "wifi";
1270         char *alias = "WifiServer-123";
1271         CertStoreType storeType;
1272         int result;
1273
1274         CREATE_INSTANCE
1275         CertSvcString Alias, Path, Pass;
1276
1277         Alias.privateHandler = (char *)alias;
1278         Alias.privateLength = strlen(alias);
1279         Pass.privateHandler = (char *)pass;
1280         Pass.privateLength = strlen(pass);
1281         Path.privateHandler = (char *)path;
1282         Path.privateLength = strlen(path);
1283
1284         /* importing p12/pfx to system store should fail */
1285         storeType = SYSTEM_STORE;
1286         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1287         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
1288
1289         /* Importing invalid pfx file to valid store should fail */
1290         storeType = WIFI_STORE;
1291         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1292         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PFX file to WIFI store failed.");
1293
1294         /* Importing invalid pfx file to valid store should fail */
1295         storeType = VPN_STORE;
1296         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1297         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PFX file to VPN store failed.");
1298
1299         /* Importing invalid pfx file to valid store should fail */
1300         storeType = EMAIL_STORE;
1301         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1302         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PFX file to EMAIL store failed.");
1303
1304         /* Importing invalid pfx file to valid store should fail */
1305         storeType = (CertStoreType) (EMAIL_STORE | VPN_STORE | WIFI_STORE);
1306         result = certsvc_pkcs12_import_from_file_to_store(instance, storeType, Path, Pass, Alias);
1307         RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Importing PFX file to EMAIL store failed.");
1308
1309         FREE_INSTANCE
1310 }
1311
1312 /* Set the status of the certificate to disabled/enabled in wifi,vpn,email store */
1313 RUNNER_TEST(CERTSVC_PKCS12_1026_deleting_a_certificate_from_invalid_store) {
1314
1315         CertStoreType storeType =  (CertStoreType) (WIFI_STORE);
1316         CertSvcStoreCertList* certList = NULL;
1317         CertStatus Status;
1318         CertStatus status;
1319         size_t length;
1320         int result;
1321         CertSvcString Alias;
1322
1323         CREATE_INSTANCE
1324
1325         /* Getting certificate list from invalid store should fail */
1326         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
1327         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1328         while(certList!=NULL)
1329         {
1330                 Alias.privateHandler = certList->gname;
1331                 Alias.privateLength = strlen((const char*)certList->gname);
1332
1333                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)-1, Alias, &status);
1334                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1335
1336                 Status=DISABLED;
1337                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)-1, DISABLED, Alias, Status);
1338                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1339
1340                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)-1, Alias, &status);
1341                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1342
1343                 Status=ENABLED;
1344                 result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)-1, DISABLED, Alias, Status);
1345                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Set certificate status to system store failed.");
1346
1347                 result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)-1, Alias, &status);
1348                 RUNNER_ASSERT_MSG(result!=CERTSVC_SUCCESS, "Get certificate status from system store failed.");
1349
1350                 certList = certList->next;
1351         }
1352
1353         FREE_INSTANCE
1354 }
1355
1356 #define EAP_TLS_USER_CERT_PATH   "user_cert.pem"
1357 #define EAP_TLS_PATH             "/tmp/"
1358 #define EAP_TLS_CA_CERT_PATH     "ca_cert.pem"
1359 #define EAP_TLS_PRIVATEKEY_PATH  "privatekey.pem"
1360
1361 /* Set the status of the certificate to disabled/enabled in wifi,vpn,email store */
1362 RUNNER_TEST(CERTSVC_PKCS12_1027_get_alias_name_from_gname_from_store) {
1363
1364         CertStoreType storeType =  (CertStoreType) (WIFI_STORE);
1365         CertSvcStoreCertList* certList = NULL;
1366         CertSvcCertificate user_certificate;
1367         CertSvcCertificateList cert_list;
1368         CertSvcCertificate ca_certificate;
1369         CertSvcCertificate *selected_certificate = NULL;
1370         size_t length;
1371         int result;
1372         int count=1;
1373         int validity;
1374         size_t cert_counts = 0;
1375         CertSvcString Alias;
1376         char *alias = NULL;
1377         X509 *x509 = NULL;
1378         FILE *fp = NULL;
1379         EVP_PKEY *privatekey = NULL;
1380         char privatekey_path[512];
1381         char ca_cert_path[512];
1382         char user_cert_path[512];
1383         int cert_index = 0;
1384
1385         CREATE_INSTANCE
1386
1387         /* Getting certificate list from invalid store should fail */
1388         result = certsvc_pkcs12_get_certificate_list_from_store(instance, storeType, DISABLED, &certList, &length);
1389         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1390         while(certList!=NULL) {
1391                 Alias.privateHandler = certList->gname;
1392                 Alias.privateLength = strlen((const char*)certList->gname);
1393
1394                 result = certsvc_pkcs12_get_alias_name_for_certificate_in_store(instance, certList->storeType, Alias, &alias);
1395                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting alias name from gname failed.");
1396
1397         result = certsvc_pkcs12_load_certificate_list_from_store(instance, certList->storeType, Alias, &cert_list);
1398         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "failed to certsvc_pkcs12_load_certificate_list");
1399
1400         result = certsvc_certificate_list_get_length(cert_list, &cert_counts);
1401         RUNNER_ASSERT_MSG(cert_counts >= 1, "there is no certificates");
1402
1403         selected_certificate = new CertSvcCertificate[cert_counts];
1404         RUNNER_ASSERT_MSG(selected_certificate != NULL, "failed to allocate memory");
1405
1406         result = certsvc_certificate_list_get_one(cert_list, 0, &user_certificate);
1407         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "failed to certsvc_certificate_list_get_one");
1408
1409                 result = certsvc_certificate_dup_x509(user_certificate, &x509);
1410
1411         sprintf(user_cert_path, "/usr/share/cert-svc/pkcs12/file_%d", count++);
1412         fp = fopen(user_cert_path, "w");
1413         RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
1414
1415                 if (count==5) break;
1416
1417         result = PEM_write_X509(fp, x509);
1418         fclose(fp);
1419         certsvc_certificate_free_x509(x509);
1420                 certList = certList->next;
1421
1422                 cert_index = cert_counts - 1;
1423                 selected_certificate[0] = user_certificate;
1424
1425         sprintf(ca_cert_path, "%s%s_%s", EAP_TLS_PATH, certList->gname, EAP_TLS_CA_CERT_PATH);
1426         while (cert_index) {
1427                 result = certsvc_certificate_list_get_one(cert_list, cert_index, &ca_certificate);
1428                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to certsvc_certificate_list_get_one");
1429
1430                 selected_certificate[cert_counts-cert_index] = ca_certificate;
1431                 cert_index--;
1432
1433                 result = certsvc_certificate_dup_x509(ca_certificate, &x509);
1434
1435                 fp = fopen(ca_cert_path, "a");
1436                 RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
1437
1438                 result = PEM_write_X509(fp, x509);
1439                 fclose(fp);
1440                 certsvc_certificate_free_x509(x509);
1441         }
1442         result = certsvc_certificate_verify(selected_certificate[0], selected_certificate, cert_counts, NULL, 0, &validity);
1443         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to verify ca_certificate");
1444         RUNNER_ASSERT_MSG(validity != 0, "Invalid certificate");
1445
1446         result = certsvc_pkcs12_dup_evp_pkey_from_store(instance, WIFI_STORE, Alias, &privatekey);
1447         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Failed to duplicate the private key for a certificate from wifi store");
1448
1449         sprintf(privatekey_path, "%s%s_%s", EAP_TLS_PATH, certList->gname, EAP_TLS_PRIVATEKEY_PATH);
1450         fp = fopen(privatekey_path, "w");
1451         RUNNER_ASSERT_MSG(fp != NULL, "Failed to open the file for writing");
1452
1453         result = PEM_write_PrivateKey(fp, privatekey, NULL, NULL, 0, NULL, NULL);
1454         fclose(fp);
1455         certsvc_pkcs12_free_evp_pkey(privatekey);
1456         }
1457
1458     delete []selected_certificate;
1459
1460         FREE_INSTANCE
1461 }
1462
1463 /* Set the status of the certificate to disabled/enabled in wifi,vpn,email store */
1464 RUNNER_TEST(CERTSVC_PKCS12_1028_certsvc_set_cert_to_disabled_and_get_status_for_individual_store) {
1465
1466         CertSvcStoreCertList* certList = NULL;
1467         CertSvcStoreCertList* tmpNode = NULL;
1468         int array[3]={VPN_STORE,WIFI_STORE,EMAIL_STORE};
1469         int result = CERTSVC_SUCCESS;
1470         CertSvcString Alias;
1471         CertStatus Status;
1472         CertStatus status;
1473         size_t length = 0;
1474         int count = 0;
1475     int i;
1476
1477         CREATE_INSTANCE
1478
1479         for(int j=0;j<3;j++)
1480         {
1481         i = array[j];
1482
1483                 result = certsvc_pkcs12_get_certificate_list_from_store(instance, (CertStoreType)i, ENABLED, &certList, &length);
1484                 RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Getting certificate list from store failed.");
1485                 tmpNode = certList;
1486                 while(certList!=NULL)
1487                 {
1488                         count++;
1489                         Alias.privateHandler = certList->gname;
1490                         Alias.privateLength = strlen((const char*)certList->gname);
1491
1492                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1493                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from store failed.");
1494
1495                         Status=DISABLED;
1496                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, ENABLED, Alias, Status);
1497                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to store failed.");
1498
1499                         status = DISABLED;
1500                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1501                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from store failed.");
1502
1503                         Status=ENABLED;
1504                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, ENABLED, Alias, Status);
1505                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to store failed.");
1506
1507                         status = DISABLED;
1508                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1509                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from store failed.");
1510
1511                         Status=DISABLED;
1512                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, DISABLED, Alias, Status);
1513                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to store failed.");
1514
1515                         status = DISABLED;
1516                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1517                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from store failed.");
1518
1519                         Status=ENABLED;
1520                         result = certsvc_pkcs12_set_certificate_status_to_store(instance, (CertStoreType)i, DISABLED, Alias, Status);
1521                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Set certificate status to store failed.");
1522
1523                         status = DISABLED;
1524                         result = certsvc_pkcs12_get_certificate_status_from_store(instance, (CertStoreType)i, Alias, &status);
1525                         RUNNER_ASSERT_MSG(result==CERTSVC_SUCCESS, "Get certificate status from store failed.");
1526
1527                         certList = certList->next;
1528                 }
1529
1530                 certsvc_pkcs12_free_certificate_list_loaded_from_store(instance, &tmpNode);
1531         }
1532
1533         FREE_INSTANCE
1534 }