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