test/pkcs12_helper.c

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