test/helpers/pkcs12.c

   1 /*
   2  * Copyright 2020-2021 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <stdlib.h>
  13
  14 #include "internal/nelem.h"
  15
  16 #include <openssl/pkcs12.h>
  17 #include <openssl/x509.h>
  18 #include <openssl/x509v3.h>
  19 #include <openssl/pem.h>
  20
  21 #include "../testutil.h"
  22 #include "pkcs12.h" /* from the same directory */
  23
  24 /* Set this to > 0 write test data to file */
  25 static int write_files = 0;
  26
  27 static int legacy = 0;
  28
  29 static OSSL_LIB_CTX *test_ctx = NULL;
  30 static const char *test_propq = NULL;
  31
  32 /* -------------------------------------------------------------------------
  33  * Local function declarations
  34  */
  35
  36 static int add_attributes(PKCS12_SAFEBAG *bag, const PKCS12_ATTR *attrs);
  37
  38 static void generate_p12(PKCS12_BUILDER *pb, const PKCS12_ENC *mac);
  39 static int write_p12(PKCS12 *p12, const char *outfile);
  40
  41 static PKCS12 *from_bio_p12(BIO *bio, const PKCS12_ENC *mac);
  42 static PKCS12 *read_p12(const char *infile, const PKCS12_ENC *mac);
  43 static int check_p12_mac(PKCS12 *p12, const PKCS12_ENC *mac);
  44 static int check_asn1_string(const ASN1_TYPE *av, const char *txt);
  45 static int check_attrs(const STACK_OF(X509_ATTRIBUTE) *bag_attrs, const PKCS12_ATTR *attrs);
  46
  47
  48 /* --------------------------------------------------------------------------
  49  * Global settings
  50  */
  51
  52 void PKCS12_helper_set_write_files(int enable)
  53 {
  54     write_files = enable;
  55 }
  56
  57 void PKCS12_helper_set_legacy(int enable)
  58 {
  59     legacy = enable;
  60 }
  61
  62 void PKCS12_helper_set_libctx(OSSL_LIB_CTX *libctx)
  63 {
  64     test_ctx = libctx;
  65 }
  66
  67 void PKCS12_helper_set_propq(const char *propq)
  68 {
  69     test_propq = propq;
  70 }
  71
  72
  73 /* --------------------------------------------------------------------------
  74  * Test data load functions
  75  */
  76
  77 static X509 *load_cert_asn1(const unsigned char *bytes, int len)
  78 {
  79     X509 *cert = NULL;
  80
  81     cert = d2i_X509(NULL, &bytes, len);
  82     if (!TEST_ptr(cert))
  83         goto err;
  84 err:
  85     return cert;
  86 }
  87
  88 static EVP_PKEY *load_pkey_asn1(const unsigned char *bytes, int len)
  89 {
  90     EVP_PKEY *pkey = NULL;
  91
  92     pkey = d2i_AutoPrivateKey(NULL, &bytes, len);
  93     if (!TEST_ptr(pkey))
  94         goto err;
  95 err:
  96     return pkey;
  97 }
  98
  99 /* -------------------------------------------------------------------------
 100  * PKCS12 builder
 101  */
 102
 103 PKCS12_BUILDER *new_pkcs12_builder(const char *filename)
 104 {
 105     PKCS12_BUILDER *pb = OPENSSL_malloc(sizeof(PKCS12_BUILDER));
 106     if (!TEST_ptr(pb))
 107         return NULL;
 108
 109     pb->filename = filename;
 110     pb->success = 1;
 111     return pb;
 112 }
 113
 114 int end_pkcs12_builder(PKCS12_BUILDER *pb)
 115 {
 116     int result = pb->success;
 117
 118     OPENSSL_free(pb);
 119     return result;
 120 }
 121
 122
 123 void start_pkcs12(PKCS12_BUILDER *pb)
 124 {
 125     pb->safes = NULL;
 126 }
 127
 128
 129 void end_pkcs12(PKCS12_BUILDER *pb)
 130 {
 131     if (!pb->success)
 132         return;
 133     generate_p12(pb, NULL);
 134 }
 135
 136
 137 void end_pkcs12_with_mac(PKCS12_BUILDER *pb, const PKCS12_ENC *mac)
 138 {
 139     if (!pb->success)
 140         return;
 141     generate_p12(pb, mac);
 142 }
 143
 144
 145 /* Generate the PKCS12 encoding and write to memory bio */
 146 static void generate_p12(PKCS12_BUILDER *pb, const PKCS12_ENC *mac)
 147 {
 148     PKCS12 *p12;
 149     EVP_MD *md = NULL;
 150
 151     if (!pb->success)
 152         return;
 153
 154     pb->p12bio = BIO_new(BIO_s_mem());
 155     if (!TEST_ptr(pb->p12bio)) {
 156         pb->success = 0;
 157         return;
 158     }
 159     if (legacy)
 160         p12 = PKCS12_add_safes(pb->safes, 0);
 161     else
 162         p12 = PKCS12_add_safes_ex(pb->safes, 0, test_ctx, test_propq);
 163     if (!TEST_ptr(p12)) {
 164         pb->success = 0;
 165         goto err;
 166     }
 167     sk_PKCS7_pop_free(pb->safes, PKCS7_free);
 168
 169     if (mac != NULL) {
 170         if (legacy)
 171             md = (EVP_MD *)EVP_get_digestbynid(mac->nid);
 172         else
 173             md = EVP_MD_fetch(test_ctx, OBJ_nid2sn(mac->nid), test_propq);
 174
 175         if (!TEST_true(PKCS12_set_mac(p12, mac->pass, strlen(mac->pass),
 176                                       NULL, 0, mac->iter, md))) {
 177             pb->success = 0;
 178             goto err;
 179         }
 180     }
 181     i2d_PKCS12_bio(pb->p12bio, p12);
 182
 183     /* Can write to file here for debug */
 184     if (write_files)
 185         write_p12(p12, pb->filename);
 186 err:
 187     if (!legacy && md != NULL)
 188         EVP_MD_free(md);
 189     PKCS12_free(p12);
 190 }
 191
 192
 193 static int write_p12(PKCS12 *p12, const char *outfile)
 194 {
 195     int ret = 0;
 196     BIO *out = BIO_new_file(outfile, "w");
 197
 198     if (out == NULL)
 199         goto err;
 200
 201     if (!TEST_int_eq(i2d_PKCS12_bio(out, p12), 1))
 202         goto err;
 203     ret = 1;
 204 err:
 205     BIO_free(out);
 206     return ret;
 207 }
 208
 209 static PKCS12 *from_bio_p12(BIO *bio, const PKCS12_ENC *mac)
 210 {
 211     PKCS12 *p12 = NULL;
 212
 213     /* Supply a p12 with library context/propq to the d2i decoder*/
 214     if (!legacy) {
 215         p12 = PKCS12_init_ex(NID_pkcs7_data, test_ctx, test_propq);
 216         if (!TEST_ptr(p12))
 217             goto err;
 218     }
 219     p12 = d2i_PKCS12_bio(bio, &p12);
 220     BIO_free(bio);
 221     if (!TEST_ptr(p12))
 222         goto err;
 223     if (mac == NULL) {
 224         if (!TEST_false(PKCS12_mac_present(p12)))
 225             goto err;
 226     } else {
 227         if (!check_p12_mac(p12, mac))
 228             goto err;
 229     }
 230     return p12;
 231 err:
 232     PKCS12_free(p12);
 233     return NULL;
 234 }
 235
 236
 237 /* For use with existing files */
 238 static PKCS12 *read_p12(const char *infile, const PKCS12_ENC *mac)
 239 {
 240     PKCS12 *p12 = NULL;
 241     BIO *in = BIO_new_file(infile, "r");
 242
 243     if (in == NULL)
 244         goto err;
 245     p12 = d2i_PKCS12_bio(in, NULL);
 246     BIO_free(in);
 247     if (!TEST_ptr(p12))
 248         goto err;
 249     if (mac == NULL) {
 250         if (!TEST_false(PKCS12_mac_present(p12)))
 251             goto err;
 252     } else {
 253         if (!check_p12_mac(p12, mac))
 254             goto err;
 255     }
 256     return p12;
 257 err:
 258     PKCS12_free(p12);
 259     return NULL;
 260 }
 261
 262 static int check_p12_mac(PKCS12 *p12, const PKCS12_ENC *mac)
 263 {
 264     return TEST_true(PKCS12_mac_present(p12))
 265         && TEST_true(PKCS12_verify_mac(p12, mac->pass, strlen(mac->pass)));
 266 }
 267
 268
 269 /* -------------------------------------------------------------------------
 270  * PKCS7 content info builder
 271  */
 272
 273 void start_contentinfo(PKCS12_BUILDER *pb)
 274 {
 275     pb->bags = NULL;
 276 }
 277
 278
 279 void end_contentinfo(PKCS12_BUILDER *pb)
 280 {
 281     if (pb->success && pb->bags != NULL) {
 282         if (!TEST_true(PKCS12_add_safe(&pb->safes, pb->bags, -1, 0, NULL)))
 283             pb->success = 0;
 284     }
 285     sk_PKCS12_SAFEBAG_pop_free(pb->bags, PKCS12_SAFEBAG_free);
 286     pb->bags = NULL;
 287 }
 288
 289
 290 void end_contentinfo_encrypted(PKCS12_BUILDER *pb, const PKCS12_ENC *enc)
 291 {
 292     if (pb->success && pb->bags != NULL) {
 293         if (legacy) {
 294             if (!TEST_true(PKCS12_add_safe(&pb->safes, pb->bags, enc->nid,
 295                                            enc->iter, enc->pass)))
 296                 pb->success = 0;
 297         } else {
 298             if (!TEST_true(PKCS12_add_safe_ex(&pb->safes, pb->bags, enc->nid,
 299                                               enc->iter, enc->pass, test_ctx,
 300                                               test_propq)))
 301                 pb->success = 0;
 302         }
 303     }
 304     sk_PKCS12_SAFEBAG_pop_free(pb->bags, PKCS12_SAFEBAG_free);
 305     pb->bags = NULL;
 306 }
 307
 308
 309 static STACK_OF(PKCS12_SAFEBAG) *decode_contentinfo(STACK_OF(PKCS7) *safes, int idx, const PKCS12_ENC *enc)
 310 {
 311     STACK_OF(PKCS12_SAFEBAG) *bags = NULL;
 312     int bagnid;
 313     PKCS7 *p7 = sk_PKCS7_value(safes, idx);
 314
 315     if (!TEST_ptr(p7))
 316         goto err;
 317
 318     bagnid = OBJ_obj2nid(p7->type);
 319     if (enc) {
 320         if (!TEST_int_eq(bagnid, NID_pkcs7_encrypted))
 321             goto err;
 322         /* TODO: Check algorithm (iterations?) against what we originally set */
 323         bags = PKCS12_unpack_p7encdata(p7, enc->pass, strlen(enc->pass));
 324     } else {
 325         if (!TEST_int_eq(bagnid, NID_pkcs7_data))
 326             goto err;
 327         bags = PKCS12_unpack_p7data(p7);
 328     }
 329     if (!TEST_ptr(bags))
 330         goto err;
 331
 332     return bags;
 333 err:
 334     return NULL;
 335 }
 336
 337
 338 /* -------------------------------------------------------------------------
 339  * PKCS12 safeBag/attribute builder
 340  */
 341
 342 static int add_attributes(PKCS12_SAFEBAG *bag, const PKCS12_ATTR *attrs)
 343 {
 344     int ret = 0;
 345     int attr_nid;
 346     const PKCS12_ATTR *p_attr = attrs;
 347
 348     if (attrs == NULL)
 349         return 1;
 350
 351     while (p_attr->oid != NULL) {
 352         TEST_info("Adding attribute %s = %s", p_attr->oid, p_attr->value);
 353         attr_nid = OBJ_txt2nid(p_attr->oid);
 354
 355         if (attr_nid == NID_friendlyName) {
 356             if (!TEST_true(PKCS12_add_friendlyname(bag, p_attr->value, -1)))
 357                 goto err;
 358         } else if (attr_nid == NID_localKeyID) {
 359             if (!TEST_true(PKCS12_add_localkeyid(bag, (unsigned char *)p_attr->value,
 360                                                  strlen(p_attr->value))))
 361                 goto err;
 362         } else {
 363             /* Custom attribute values limited to ASCII in these tests */
 364             if (!TEST_true(PKCS12_add1_attr_by_txt(bag, p_attr->oid, MBSTRING_ASC,
 365                                                    (unsigned char *)p_attr->value,
 366                                                    strlen(p_attr->value))))
 367                 goto err;
 368         }
 369         p_attr++;
 370     }
 371     ret = 1;
 372 err:
 373     return ret;
 374 }
 375
 376 void add_certbag(PKCS12_BUILDER *pb, const unsigned char *bytes, int len,
 377                  const PKCS12_ATTR *attrs)
 378 {
 379     PKCS12_SAFEBAG *bag = NULL;
 380     X509 *cert = NULL;
 381     char *name;
 382
 383     if (!pb->success)
 384         return;
 385
 386     cert = load_cert_asn1(bytes, len);
 387     if (!TEST_ptr(cert)) {
 388         pb->success = 0;
 389         return;
 390     }
 391
 392     name = X509_NAME_oneline(X509_get_subject_name(cert), NULL, 0);
 393     TEST_info("Adding certificate <%s>", name);
 394     OPENSSL_free(name);
 395
 396     bag = PKCS12_add_cert(&pb->bags, cert);
 397     if (!TEST_ptr(bag)) {
 398         pb->success = 0;
 399         goto err;
 400     }
 401
 402     if (!TEST_true(add_attributes(bag, attrs))) {
 403         pb->success = 0;
 404         goto err;
 405     }
 406 err:
 407     X509_free(cert);
 408 }
 409
 410 void add_keybag(PKCS12_BUILDER *pb, const unsigned char *bytes, int len,
 411                 const PKCS12_ATTR *attrs, const PKCS12_ENC *enc)
 412 {
 413     PKCS12_SAFEBAG *bag = NULL;
 414     EVP_PKEY *pkey = NULL;
 415
 416     if (!pb->success)
 417         return;
 418
 419     TEST_info("Adding key");
 420
 421     pkey = load_pkey_asn1(bytes, len);
 422     if (!TEST_ptr(pkey)) {
 423         pb->success = 0;
 424         return;
 425     }
 426
 427     if (legacy)
 428         bag = PKCS12_add_key(&pb->bags, pkey, 0 /*keytype*/, enc->iter, enc->nid, enc->pass);
 429     else
 430         bag = PKCS12_add_key_ex(&pb->bags, pkey, 0 /*keytype*/, enc->iter, enc->nid, enc->pass,
 431                                 test_ctx, test_propq);
 432     if (!TEST_ptr(bag)) {
 433         pb->success = 0;
 434         goto err;
 435     }
 436     if (!add_attributes(bag, attrs))
 437         pb->success = 0;
 438 err:
 439     EVP_PKEY_free(pkey);
 440 }
 441
 442 void add_secretbag(PKCS12_BUILDER *pb, int secret_nid, const char *secret,
 443                                const PKCS12_ATTR *attrs)
 444 {
 445     PKCS12_SAFEBAG *bag = NULL;
 446
 447     if (!pb->success)
 448         return;
 449
 450     TEST_info("Adding secret <%s>", secret);
 451
 452     bag = PKCS12_add_secret(&pb->bags, secret_nid, (const unsigned char *)secret, strlen(secret));
 453     if (!TEST_ptr(bag)) {
 454         pb->success = 0;
 455         return;
 456     }
 457     if (!add_attributes(bag, attrs))
 458         pb->success = 0;
 459 }
 460
 461
 462 /* -------------------------------------------------------------------------
 463  * PKCS12 structure checking
 464  */
 465
 466 static int check_asn1_string(const ASN1_TYPE *av, const char *txt)
 467 {
 468     int ret = 0;
 469     char *value = NULL;
 470
 471     if (!TEST_ptr(av))
 472         goto err;
 473
 474     switch (av->type) {
 475     case V_ASN1_BMPSTRING:
 476         value = OPENSSL_uni2asc(av->value.bmpstring->data,
 477                                 av->value.bmpstring->length);
 478         if (!TEST_str_eq(txt, (char *)value))
 479             goto err;
 480         break;
 481
 482     case V_ASN1_UTF8STRING:
 483         if (!TEST_str_eq(txt, (char *)av->value.utf8string->data))
 484             goto err;
 485         break;
 486
 487     case V_ASN1_OCTET_STRING:
 488         if (!TEST_str_eq(txt, (char *)av->value.octet_string->data))
 489             goto err;
 490         break;
 491
 492     default:
 493         /* Tests do not support other attribute types currently */
 494         goto err;
 495     }
 496     ret = 1;
 497 err:
 498     OPENSSL_free(value);
 499     return ret;
 500 }
 501
 502 static int check_attrs(const STACK_OF(X509_ATTRIBUTE) *bag_attrs, const PKCS12_ATTR *attrs)
 503 {
 504     int ret = 0;
 505     X509_ATTRIBUTE *attr;
 506     ASN1_TYPE *av;
 507     int i, j;
 508     char attr_txt[100];
 509
 510     for (i = 0; i < sk_X509_ATTRIBUTE_num(bag_attrs); i++) {
 511         const PKCS12_ATTR *p_attr = attrs;
 512         ASN1_OBJECT *attr_obj;
 513
 514         attr = sk_X509_ATTRIBUTE_value(bag_attrs, i);
 515         attr_obj = X509_ATTRIBUTE_get0_object(attr);
 516         OBJ_obj2txt(attr_txt, 100, attr_obj, 0);
 517
 518         while(p_attr->oid != NULL) {
 519             /* Find a matching attribute type */
 520             if (strcmp(p_attr->oid, attr_txt) == 0) {
 521
 522                 /* TODO: Handle multi-value attributes */
 523                 if (!TEST_int_eq(X509_ATTRIBUTE_count(attr), 1))
 524                     goto err;
 525
 526                 for (j = 0; j < X509_ATTRIBUTE_count(attr); j++)
 527                 {
 528                     av = X509_ATTRIBUTE_get0_type(attr, j);
 529                     if (!TEST_true(check_asn1_string(av, p_attr->value)))
 530                         goto err;
 531                 }
 532                 break;
 533             }
 534             p_attr++;
 535         }
 536     }
 537     ret = 1;
 538 err:
 539     return ret;
 540 }
 541
 542 void check_certbag(PKCS12_BUILDER *pb, const unsigned char *bytes, int len,
 543                    const PKCS12_ATTR *attrs)
 544 {
 545     X509 *x509 = NULL;
 546     X509 *ref_x509 = NULL;
 547     const PKCS12_SAFEBAG *bag;
 548
 549     if (!pb->success)
 550         return;
 551
 552     bag = sk_PKCS12_SAFEBAG_value(pb->bags, pb->bag_idx++);
 553     if (!TEST_ptr(bag)) {
 554         pb->success = 0;
 555         return;
 556     }
 557     if (!check_attrs(PKCS12_SAFEBAG_get0_attrs(bag), attrs)
 558         || !TEST_int_eq(PKCS12_SAFEBAG_get_nid(bag), NID_certBag)
 559         || !TEST_int_eq(PKCS12_SAFEBAG_get_bag_nid(bag), NID_x509Certificate)) {
 560         pb->success = 0;
 561         return;
 562     }
 563     x509 = PKCS12_SAFEBAG_get1_cert(bag);
 564     if (!TEST_ptr(x509)) {
 565         pb->success = 0;
 566         goto err;
 567     }
 568     ref_x509 = load_cert_asn1(bytes, len);
 569     if (!TEST_false(X509_cmp(x509, ref_x509)))
 570         pb->success = 0;
 571 err:
 572     X509_free(x509);
 573     X509_free(ref_x509);
 574 }
 575
 576 void check_keybag(PKCS12_BUILDER *pb, const unsigned char *bytes, int len,
 577                   const PKCS12_ATTR *attrs, const PKCS12_ENC *enc)
 578 {
 579     EVP_PKEY *pkey = NULL;
 580     EVP_PKEY *ref_pkey = NULL;
 581     PKCS8_PRIV_KEY_INFO *p8;
 582     const PKCS8_PRIV_KEY_INFO *p8c;
 583     const PKCS12_SAFEBAG *bag;
 584
 585     if (!pb->success)
 586         return;
 587
 588     bag = sk_PKCS12_SAFEBAG_value(pb->bags, pb->bag_idx++);
 589     if (!TEST_ptr(bag)) {
 590         pb->success = 0;
 591         return;
 592     }
 593
 594     if (!check_attrs(PKCS12_SAFEBAG_get0_attrs(bag), attrs)) {
 595         pb->success = 0;
 596         return;
 597     }
 598
 599     switch (PKCS12_SAFEBAG_get_nid(bag)) {
 600     case NID_keyBag:
 601         p8c = PKCS12_SAFEBAG_get0_p8inf(bag);
 602         if (!TEST_ptr(pkey = EVP_PKCS82PKEY(p8c))) {
 603             pb->success = 0;
 604             goto err;
 605         }
 606         /* TODO: handle key attributes */
 607         /* PKCS8_pkey_get0_attrs(p8c); */
 608         break;
 609
 610     case NID_pkcs8ShroudedKeyBag:
 611         if (legacy)
 612             p8 = PKCS12_decrypt_skey(bag, enc->pass, strlen(enc->pass));
 613         else
 614             p8 = PKCS12_decrypt_skey_ex(bag, enc->pass, strlen(enc->pass), test_ctx, test_propq);
 615         if (!TEST_ptr(p8)) {
 616             pb->success = 0;
 617             goto err;
 618         }
 619         if (!TEST_ptr(pkey = EVP_PKCS82PKEY(p8))) {
 620             PKCS8_PRIV_KEY_INFO_free(p8);
 621             pb->success = 0;
 622             goto err;
 623         }
 624         /* TODO: handle key attributes */
 625         /* PKCS8_pkey_get0_attrs(p8); */
 626         PKCS8_PRIV_KEY_INFO_free(p8);
 627         break;
 628
 629     default:
 630         pb->success = 0;
 631         goto err;
 632     }
 633
 634     /* PKEY compare returns 1 for match */
 635     ref_pkey = load_pkey_asn1(bytes, len);
 636     if (!TEST_true(EVP_PKEY_eq(pkey, ref_pkey)))
 637         pb->success = 0;
 638 err:
 639     EVP_PKEY_free(pkey);
 640     EVP_PKEY_free(ref_pkey);
 641 }
 642
 643 void check_secretbag(PKCS12_BUILDER *pb, int secret_nid, const char *secret, const PKCS12_ATTR *attrs)
 644 {
 645     const PKCS12_SAFEBAG *bag;
 646
 647     if (!pb->success)
 648         return;
 649
 650     bag = sk_PKCS12_SAFEBAG_value(pb->bags, pb->bag_idx++);
 651     if (!TEST_ptr(bag)) {
 652         pb->success = 0;
 653         return;
 654     }
 655
 656     if (!check_attrs(PKCS12_SAFEBAG_get0_attrs(bag), attrs)
 657         || !TEST_int_eq(PKCS12_SAFEBAG_get_nid(bag), NID_secretBag)
 658         || !TEST_int_eq(PKCS12_SAFEBAG_get_bag_nid(bag), secret_nid)
 659         || !TEST_true(check_asn1_string(PKCS12_SAFEBAG_get0_bag_obj(bag), secret)))
 660         pb->success = 0;
 661 }
 662
 663
 664 void start_check_pkcs12(PKCS12_BUILDER *pb)
 665 {
 666     PKCS12 *p12;
 667
 668     if (!pb->success)
 669         return;
 670
 671     p12 = from_bio_p12(pb->p12bio, NULL);
 672     if (!TEST_ptr(p12)) {
 673         pb->success = 0;
 674         return;
 675     }
 676     pb->safes = PKCS12_unpack_authsafes(p12);
 677     if (!TEST_ptr(pb->safes))
 678         pb->success = 0;
 679
 680     pb->safe_idx = 0;
 681     PKCS12_free(p12);
 682 }
 683
 684 void start_check_pkcs12_with_mac(PKCS12_BUILDER *pb, const PKCS12_ENC *mac)
 685 {
 686     PKCS12 *p12;
 687
 688     if (!pb->success)
 689         return;
 690
 691     p12 = from_bio_p12(pb->p12bio, mac);
 692     if (!TEST_ptr(p12)) {
 693         pb->success = 0;
 694         return;
 695     }
 696     pb->safes = PKCS12_unpack_authsafes(p12);
 697     if (!TEST_ptr(pb->safes))
 698         pb->success = 0;
 699
 700     pb->safe_idx = 0;
 701     PKCS12_free(p12);
 702 }
 703
 704 void start_check_pkcs12_file(PKCS12_BUILDER *pb)
 705 {
 706     PKCS12 *p12;
 707
 708     if (!pb->success)
 709         return;
 710
 711     p12 = read_p12(pb->filename, NULL);
 712     if (!TEST_ptr(p12)) {
 713         pb->success = 0;
 714         return;
 715     }
 716     pb->safes = PKCS12_unpack_authsafes(p12);
 717     if (!TEST_ptr(pb->safes))
 718         pb->success = 0;
 719
 720     pb->safe_idx = 0;
 721     PKCS12_free(p12);
 722 }
 723
 724 void start_check_pkcs12_file_with_mac(PKCS12_BUILDER *pb, const PKCS12_ENC *mac)
 725 {
 726     PKCS12 *p12;
 727
 728     if (!pb->success)
 729         return;
 730
 731     p12 = read_p12(pb->filename, mac);
 732     if (!TEST_ptr(p12)) {
 733         pb->success = 0;
 734         return;
 735     }
 736     pb->safes = PKCS12_unpack_authsafes(p12);
 737     if (!TEST_ptr(pb->safes))
 738         pb->success = 0;
 739
 740     pb->safe_idx = 0;
 741     PKCS12_free(p12);
 742 }
 743
 744 void end_check_pkcs12(PKCS12_BUILDER *pb)
 745 {
 746     if (!pb->success)
 747         return;
 748
 749     sk_PKCS7_pop_free(pb->safes, PKCS7_free);
 750 }
 751
 752
 753 void start_check_contentinfo(PKCS12_BUILDER *pb)
 754 {
 755     if (!pb->success)
 756         return;
 757
 758     pb->bag_idx = 0;
 759     pb->bags = decode_contentinfo(pb->safes, pb->safe_idx++, NULL);
 760     if (!TEST_ptr(pb->bags)) {
 761         pb->success = 0;
 762         return;
 763     }
 764     TEST_info("Decoding %d bags", sk_PKCS12_SAFEBAG_num(pb->bags));
 765 }
 766
 767 void start_check_contentinfo_encrypted(PKCS12_BUILDER *pb, const PKCS12_ENC *enc)
 768 {
 769     if (!pb->success)
 770         return;
 771
 772     pb->bag_idx = 0;
 773     pb->bags = decode_contentinfo(pb->safes, pb->safe_idx++, enc);
 774     if (!TEST_ptr(pb->bags)) {
 775         pb->success = 0;
 776         return;
 777     }
 778     TEST_info("Decoding %d bags", sk_PKCS12_SAFEBAG_num(pb->bags));
 779 }
 780
 781
 782 void end_check_contentinfo(PKCS12_BUILDER *pb)
 783 {
 784     if (!pb->success)
 785         return;
 786
 787     if (!TEST_int_eq(sk_PKCS12_SAFEBAG_num(pb->bags), pb->bag_idx))
 788         pb->success = 0;
 789     sk_PKCS12_SAFEBAG_pop_free(pb->bags, PKCS12_SAFEBAG_free);
 790     pb->bags = NULL;
 791 }
 792
 793