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