luna - wolfssl/src/ssl

   1/* ssl_p7p12.c
   2 *
   3 * Copyright (C) 2006-2026 wolfSSL Inc.
   4 *
   5 * This file is part of wolfSSL.
   6 *
   7 * wolfSSL is free software; you can redistribute it and/or modify
   8 * it under the terms of the GNU General Public License as published by
   9 * the Free Software Foundation; either version 3 of the License, or
  10 * (at your option) any later version.
  11 *
  12 * wolfSSL is distributed in the hope that it will be useful,
  13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 * GNU General Public License for more details.
  16 *
  17 * You should have received a copy of the GNU General Public License
  18 * along with this program; if not, write to the Free Software
  19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  20 */
  21
  22#include <wolfssl/wolfcrypt/libwolfssl_sources.h>
  23
  24#if defined(OPENSSL_EXTRA) && (defined(HAVE_FIPS) || defined(HAVE_SELFTEST))
  25    #include <wolfssl/wolfcrypt/pkcs7.h>
  26#endif
  27#if defined(OPENSSL_ALL) && defined(HAVE_PKCS7)
  28    #include <wolfssl/openssl/pkcs7.h>
  29#endif
  30
  31#if !defined(WOLFSSL_SSL_P7P12_INCLUDED)
  32    #ifndef WOLFSSL_IGNORE_FILE_WARN
  33        #warning ssl_p7p12.c does not need to be compiled separately from ssl.c
  34    #endif
  35#else
  36
  37#if !defined(WOLFCRYPT_ONLY) && !defined(NO_CERTS)
  38
  39/*******************************************************************************
  40 * START OF PKCS7 APIs
  41 ******************************************************************************/
  42#ifdef HAVE_PKCS7
  43
  44#ifdef OPENSSL_ALL
  45PKCS7* wolfSSL_PKCS7_new(void)
  46{
  47    WOLFSSL_PKCS7* pkcs7;
  48    int ret = 0;
  49
  50    pkcs7 = (WOLFSSL_PKCS7*)XMALLOC(sizeof(WOLFSSL_PKCS7), NULL,
  51                                    DYNAMIC_TYPE_PKCS7);
  52    if (pkcs7 != NULL) {
  53        XMEMSET(pkcs7, 0, sizeof(WOLFSSL_PKCS7));
  54        ret = wc_PKCS7_Init(&pkcs7->pkcs7, NULL, INVALID_DEVID);
  55    }
  56
  57    if (ret != 0 && pkcs7 != NULL) {
  58        XFREE(pkcs7, NULL, DYNAMIC_TYPE_PKCS7);
  59        pkcs7 = NULL;
  60    }
  61
  62    return (PKCS7*)pkcs7;
  63}
  64
  65/******************************************************************************
  66* wolfSSL_PKCS7_SIGNED_new - allocates PKCS7 and initialize it for a signed data
  67*
  68* RETURNS:
  69* returns pointer to the PKCS7 structure on success, otherwise returns NULL
  70*/
  71PKCS7_SIGNED* wolfSSL_PKCS7_SIGNED_new(void)
  72{
  73    byte signedData[]= { 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02};
  74    PKCS7* pkcs7 = NULL;
  75
  76    if ((pkcs7 = wolfSSL_PKCS7_new()) == NULL)
  77        return NULL;
  78    pkcs7->contentOID = SIGNED_DATA;
  79    if ((wc_PKCS7_SetContentType(pkcs7, signedData, sizeof(signedData))) < 0) {
  80        if (pkcs7) {
  81            wolfSSL_PKCS7_free(pkcs7);
  82            return NULL;
  83        }
  84    }
  85    return pkcs7;
  86}
  87
  88void wolfSSL_PKCS7_free(PKCS7* pkcs7)
  89{
  90    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
  91
  92    if (p7 != NULL) {
  93        XFREE(p7->data, NULL, DYNAMIC_TYPE_PKCS7);
  94        wc_PKCS7_Free(&p7->pkcs7);
  95        if (p7->certs)
  96            wolfSSL_sk_pop_free(p7->certs, NULL);
  97        XFREE(p7, NULL, DYNAMIC_TYPE_PKCS7);
  98    }
  99}
 100
 101void wolfSSL_PKCS7_SIGNED_free(PKCS7_SIGNED* p7)
 102{
 103    wolfSSL_PKCS7_free(p7);
 104    return;
 105}
 106
 107/**
 108 * Convert DER/ASN.1 encoded signedData structure to internal PKCS7
 109 * structure. Note, does not support detached content.
 110 *
 111 * p7 - pointer to set to address of newly created PKCS7 structure on return
 112 * in - pointer to pointer of DER/ASN.1 data
 113 * len - length of input data, bytes
 114 *
 115 * Returns newly allocated and populated PKCS7 structure or NULL on error.
 116 */
 117PKCS7* wolfSSL_d2i_PKCS7(PKCS7** p7, const unsigned char** in, int len)
 118{
 119    return wolfSSL_d2i_PKCS7_ex(p7, in, len, NULL, 0);
 120}
 121
 122/* This internal function is only decoding and setting up the PKCS7 struct. It
 123* does not verify the PKCS7 signature.
 124*
 125* RETURNS:
 126* returns pointer to a PKCS7 structure on success, otherwise returns NULL
 127*/
 128static PKCS7* wolfSSL_d2i_PKCS7_only(PKCS7** p7, const unsigned char** in,
 129    int len, byte* content, word32 contentSz)
 130{
 131    WOLFSSL_PKCS7* pkcs7 = NULL;
 132
 133    WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_ex");
 134
 135    if (in == NULL || *in == NULL || len < 0)
 136        return NULL;
 137
 138    if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)
 139        return NULL;
 140
 141    pkcs7->len = len;
 142    pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7);
 143    if (pkcs7->data == NULL) {
 144        wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 145        return NULL;
 146    }
 147    XMEMCPY(pkcs7->data, *in, pkcs7->len);
 148
 149    if (content != NULL) {
 150        pkcs7->pkcs7.content = content;
 151        pkcs7->pkcs7.contentSz = contentSz;
 152    }
 153
 154    if (p7 != NULL)
 155        *p7 = (PKCS7*)pkcs7;
 156    *in += pkcs7->len;
 157    return (PKCS7*)pkcs7;
 158}
 159
 160
 161/*****************************************************************************
 162* wolfSSL_d2i_PKCS7_ex - Converts the given unsigned char buffer of size len
 163* into a PKCS7 object.  Optionally, accepts a byte buffer of content which
 164* is stored as the PKCS7 object's content, to support detached signatures.
 165* @param content The content which is signed, in case the signature is
 166*                detached.  Ignored if NULL.
 167* @param contentSz The size of the passed in content.
 168*
 169* RETURNS:
 170* returns pointer to a PKCS7 structure on success, otherwise returns NULL
 171*/
 172PKCS7* wolfSSL_d2i_PKCS7_ex(PKCS7** p7, const unsigned char** in, int len,
 173        byte* content, word32 contentSz)
 174{
 175    WOLFSSL_PKCS7* pkcs7 = NULL;
 176
 177    WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_ex");
 178
 179    if (in == NULL || *in == NULL || len < 0)
 180        return NULL;
 181
 182    pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_d2i_PKCS7_only(p7, in, len, content,
 183            contentSz);
 184    if (pkcs7 != NULL) {
 185        if (wc_PKCS7_VerifySignedData(&pkcs7->pkcs7, pkcs7->data, pkcs7->len)
 186                                                                         != 0) {
 187            WOLFSSL_MSG("wc_PKCS7_VerifySignedData failed");
 188            wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 189            if (p7 != NULL) {
 190                *p7 = NULL;
 191            }
 192            return NULL;
 193        }
 194    }
 195
 196    return (PKCS7*)pkcs7;
 197}
 198
 199
 200/**
 201 * This API was added as a helper function for libest. It
 202 * extracts a stack of certificates from the pkcs7 object.
 203 * @param pkcs7 PKCS7 parameter object
 204 * @return WOLFSSL_STACK_OF(WOLFSSL_X509)*
 205 */
 206WOLFSSL_STACK* wolfSSL_PKCS7_to_stack(PKCS7* pkcs7)
 207{
 208    int i;
 209    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
 210    WOLF_STACK_OF(WOLFSSL_X509)* ret = NULL;
 211
 212    WOLFSSL_ENTER("wolfSSL_PKCS7_to_stack");
 213
 214    if (!p7) {
 215        WOLFSSL_MSG("Bad parameter");
 216        return NULL;
 217    }
 218
 219    if (p7->certs)
 220        return p7->certs;
 221
 222    for (i = 0; i < MAX_PKCS7_CERTS && p7->pkcs7.cert[i]; i++) {
 223        WOLFSSL_X509* x509 = wolfSSL_X509_d2i_ex(NULL, p7->pkcs7.cert[i],
 224            p7->pkcs7.certSz[i], pkcs7->heap);
 225        if (!ret)
 226            ret = wolfSSL_sk_X509_new_null();
 227        if (x509) {
 228            if (wolfSSL_sk_X509_push(ret, x509) <= 0) {
 229                wolfSSL_X509_free(x509);
 230                x509 = NULL;
 231                WOLFSSL_MSG("wolfSSL_sk_X509_push error");
 232                goto error;
 233            }
 234        }
 235        else {
 236            WOLFSSL_MSG("wolfSSL_X509_d2i error");
 237            goto error;
 238        }
 239    }
 240
 241    /* Save stack to free later */
 242    if (p7->certs)
 243        wolfSSL_sk_pop_free(p7->certs, NULL);
 244    p7->certs = ret;
 245
 246    return ret;
 247error:
 248    if (ret) {
 249        wolfSSL_sk_pop_free(ret, NULL);
 250    }
 251    return NULL;
 252}
 253
 254/**
 255 * Return stack of signers contained in PKCS7 cert.
 256 * Notes:
 257 * - Currently only PKCS#7 messages with a single signer cert is supported.
 258 * - Returned WOLFSSL_STACK must be freed by caller.
 259 *
 260 * pkcs7 - PKCS7 struct to retrieve signer certs from.
 261 * certs - currently unused
 262 * flags - flags to control function behavior.
 263 *
 264 * Return WOLFSSL_STACK of signers on success, NULL on error.
 265 */
 266WOLFSSL_STACK* wolfSSL_PKCS7_get0_signers(PKCS7* pkcs7, WOLFSSL_STACK* certs,
 267                                          int flags)
 268{
 269    WOLFSSL_X509* x509 = NULL;
 270    WOLFSSL_STACK* signers = NULL;
 271    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
 272    byte* signerCert;
 273    word32 signerCertSz;
 274
 275    if (p7 == NULL)
 276        return NULL;
 277
 278    if (flags & PKCS7_NOINTERN) {
 279        WOLFSSL_MSG("PKCS7_NOINTERN flag not supported");
 280        return NULL;
 281    }
 282
 283    /* Prefer the certificate that actually verified the signature. Falling
 284     * back to singleCert (cert[0]) would let an attacker that bundles a
 285     * trusted cert ahead of their own attacker cert have the trusted cert
 286     * reported as the signer even though it did not produce the signature.
 287     *
 288     * Copy the chosen pointer into a local before passing its address to
 289     * wolfSSL_d2i_X509; d2i_X509 advances *in by the DER length, and if
 290     * we handed it the address of the struct field directly it would
 291     * permanently corrupt the field, producing a heap-OOB read on the
 292     * next use (pointer advanced, singleCertSz unchanged). */
 293    if (p7->pkcs7.verifyCert != NULL && p7->pkcs7.verifyCertSz > 0) {
 294        signerCert   = p7->pkcs7.verifyCert;
 295        signerCertSz = p7->pkcs7.verifyCertSz;
 296    }
 297    else {
 298        signerCert   = p7->pkcs7.singleCert;
 299        signerCertSz = p7->pkcs7.singleCertSz;
 300    }
 301
 302    signers = wolfSSL_sk_X509_new_null();
 303    if (signers == NULL)
 304        return NULL;
 305
 306    if (wolfSSL_d2i_X509(&x509, (const byte**)&signerCert,
 307                         signerCertSz) == NULL) {
 308        wolfSSL_sk_X509_pop_free(signers, NULL);
 309        return NULL;
 310    }
 311
 312    if (wolfSSL_sk_X509_push(signers, x509) <= 0) {
 313        wolfSSL_X509_free(x509);
 314        wolfSSL_sk_X509_pop_free(signers, NULL);
 315        return NULL;
 316    }
 317
 318    (void)certs;
 319
 320    return signers;
 321}
 322
 323#ifndef NO_BIO
 324
 325PKCS7* wolfSSL_d2i_PKCS7_bio(WOLFSSL_BIO* bio, PKCS7** p7)
 326{
 327    WOLFSSL_PKCS7* pkcs7;
 328    int ret;
 329
 330    WOLFSSL_ENTER("wolfSSL_d2i_PKCS7_bio");
 331
 332    if (bio == NULL)
 333        return NULL;
 334
 335    if ((pkcs7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)
 336        return NULL;
 337
 338    pkcs7->len = wolfSSL_BIO_get_len(bio);
 339    if (pkcs7->len < 0){
 340        wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 341        return NULL;
 342    }
 343    pkcs7->data = (byte*)XMALLOC(pkcs7->len, NULL, DYNAMIC_TYPE_PKCS7);
 344    if (pkcs7->data == NULL) {
 345        wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 346        return NULL;
 347    }
 348
 349    if ((ret = wolfSSL_BIO_read(bio, pkcs7->data, pkcs7->len)) <= 0) {
 350        wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 351        return NULL;
 352    }
 353    /* pkcs7->len may change if using b64 for example */
 354    pkcs7->len = ret;
 355
 356    if (wc_PKCS7_VerifySignedData(&pkcs7->pkcs7, pkcs7->data, pkcs7->len)
 357                                                                         != 0) {
 358        WOLFSSL_MSG("wc_PKCS7_VerifySignedData failed");
 359        wolfSSL_PKCS7_free((PKCS7*)pkcs7);
 360        return NULL;
 361    }
 362
 363    if (p7 != NULL)
 364        *p7 = (PKCS7*)pkcs7;
 365    return (PKCS7*)pkcs7;
 366}
 367
 368int wolfSSL_i2d_PKCS7(PKCS7 *p7, unsigned char **out)
 369{
 370    byte* output = NULL;
 371    int localBuf = 0;
 372    int len;
 373    WC_RNG rng;
 374    int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
 375    WOLFSSL_ENTER("wolfSSL_i2d_PKCS7");
 376
 377    if (!out || !p7) {
 378        WOLFSSL_MSG("Bad parameter");
 379        return WOLFSSL_FAILURE;
 380    }
 381
 382    if (!p7->rng) {
 383        if (wc_InitRng(&rng) != 0) {
 384            WOLFSSL_MSG("wc_InitRng error");
 385            return WOLFSSL_FAILURE;
 386        }
 387        p7->rng = &rng; /* cppcheck-suppress autoVariables
 388                         */
 389    }
 390
 391    if ((len = wc_PKCS7_EncodeSignedData(p7, NULL, 0)) < 0) {
 392        WOLFSSL_MSG("wc_PKCS7_EncodeSignedData error");
 393        goto cleanup;
 394    }
 395
 396    if (*out == NULL) {
 397        output = (byte*)XMALLOC(len, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 398        if (!output) {
 399            WOLFSSL_MSG("malloc error");
 400            goto cleanup;
 401        }
 402        localBuf = 1;
 403    }
 404    else {
 405        output = *out;
 406    }
 407
 408    if ((len = wc_PKCS7_EncodeSignedData(p7, output, (word32)len)) < 0) {
 409        WOLFSSL_MSG("wc_PKCS7_EncodeSignedData error");
 410        goto cleanup;
 411    }
 412
 413    ret = len;
 414cleanup:
 415    if (p7->rng == &rng) {
 416        wc_FreeRng(&rng);
 417        p7->rng = NULL;
 418    }
 419    if (ret == WC_NO_ERR_TRACE(WOLFSSL_FAILURE) && localBuf)
 420        XFREE(output, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 421    if (ret != WC_NO_ERR_TRACE(WOLFSSL_FAILURE))
 422        *out = output;
 423    return ret;
 424}
 425
 426int wolfSSL_i2d_PKCS7_bio(WOLFSSL_BIO *bio, PKCS7 *p7)
 427{
 428    byte* output = NULL;
 429    int len;
 430    int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
 431    WOLFSSL_ENTER("wolfSSL_i2d_PKCS7_bio");
 432
 433    if (!bio || !p7) {
 434        WOLFSSL_MSG("Bad parameter");
 435        return WOLFSSL_FAILURE;
 436    }
 437
 438    if ((len = wolfSSL_i2d_PKCS7(p7, &output)) ==
 439        WC_NO_ERR_TRACE(WOLFSSL_FAILURE))
 440    {
 441        WOLFSSL_MSG("wolfSSL_i2d_PKCS7 error");
 442        goto cleanup;
 443    }
 444
 445    if (wolfSSL_BIO_write(bio, output, len) <= 0) {
 446        WOLFSSL_MSG("wolfSSL_BIO_write error");
 447        goto cleanup;
 448    }
 449
 450    ret = WOLFSSL_SUCCESS;
 451cleanup:
 452    XFREE(output, NULL, DYNAMIC_TYPE_TMP_BUFFER);
 453    return ret;
 454}
 455
 456/**
 457 * Creates and returns a PKCS7 signedData structure.
 458 *
 459 * Inner content type is set to DATA to match OpenSSL behavior.
 460 *
 461 * signer   - certificate to sign bundle with
 462 * pkey     - private key matching signer
 463 * certs    - optional additional set of certificates to include
 464 * in       - input data to be signed
 465 * flags    - optional set of flags to control sign behavior
 466 *
 467 *    PKCS7_BINARY   - Do not translate input data to MIME canonical
 468 *                     format (\r\n line endings), thus preventing corruption of
 469 *                     binary content.
 470 *    PKCS7_TEXT     - Prepend MIME headers for text/plain to content.
 471 *    PKCS7_DETACHED - Set signature detached, omit content from output bundle.
 472 *    PKCS7_STREAM   - initialize PKCS7 struct for signing, do not read data.
 473 *
 474 * Flags not currently supported:
 475 *    PKCS7_NOCERTS  - Do not include the signer cert in the output bundle.
 476 *    PKCS7_PARTIAL  - Allow for PKCS7_sign() to be only partially set up,
 477 *                     then signers etc to be added separately before
 478 *                     calling PKCS7_final().
 479 *
 480 * Returns valid PKCS7 structure pointer, or NULL if an error occurred.
 481 */
 482PKCS7* wolfSSL_PKCS7_sign(WOLFSSL_X509* signer, WOLFSSL_EVP_PKEY* pkey,
 483        WOLFSSL_STACK* certs, WOLFSSL_BIO* in, int flags)
 484{
 485    int err = 0;
 486    WOLFSSL_PKCS7* p7 = NULL;
 487    WOLFSSL_STACK* cert = certs;
 488
 489    WOLFSSL_ENTER("wolfSSL_PKCS7_sign");
 490
 491    if (flags & PKCS7_NOCERTS) {
 492        WOLFSSL_MSG("PKCS7_NOCERTS flag not yet supported");
 493        err = 1;
 494    }
 495
 496    if (flags & PKCS7_PARTIAL) {
 497        WOLFSSL_MSG("PKCS7_PARTIAL flag not yet supported");
 498        err = 1;
 499    }
 500
 501    if ((err == 0) && (signer == NULL || signer->derCert == NULL ||
 502                       signer->derCert->length == 0)) {
 503        WOLFSSL_MSG("Bad function arg, signer is NULL or incomplete");
 504        err = 1;
 505    }
 506
 507    if ((err == 0) && (pkey == NULL || pkey->pkey.ptr == NULL ||
 508                       pkey->pkey_sz <= 0)) {
 509        WOLFSSL_MSG("Bad function arg, pkey is NULL or incomplete");
 510        err = 1;
 511    }
 512
 513    if ((err == 0) && (in == NULL) && !(flags & PKCS7_STREAM)) {
 514        WOLFSSL_MSG("input data required unless PKCS7_STREAM used");
 515        err = 1;
 516    }
 517
 518    if ((err == 0) && ((p7 = (WOLFSSL_PKCS7*)wolfSSL_PKCS7_new()) == NULL)) {
 519        WOLFSSL_MSG("Error allocating new WOLFSSL_PKCS7");
 520        err = 1;
 521    }
 522
 523    /* load signer certificate */
 524    if (err == 0) {
 525        if (wc_PKCS7_InitWithCert(&p7->pkcs7, signer->derCert->buffer,
 526                                  signer->derCert->length) != 0) {
 527            WOLFSSL_MSG("Failed to load signer certificate");
 528            err = 1;
 529        }
 530    }
 531
 532    /* set signer private key, data types, defaults */
 533    if (err == 0) {
 534        p7->pkcs7.privateKey = (byte*)pkey->pkey.ptr;
 535        p7->pkcs7.privateKeySz = (word32)pkey->pkey_sz;
 536        p7->pkcs7.contentOID = DATA;  /* inner content default is DATA */
 537        p7->pkcs7.hashOID = SHA256h;  /* default to SHA-256 hash type */
 538        p7->type = SIGNED_DATA;       /* PKCS7_final switches on type */
 539    }
 540
 541    /* add additional chain certs if provided */
 542    while (cert && (err == 0)) {
 543        if (cert->data.x509 != NULL && cert->data.x509->derCert != NULL) {
 544            if (wc_PKCS7_AddCertificate(&p7->pkcs7,
 545                                cert->data.x509->derCert->buffer,
 546                                cert->data.x509->derCert->length) != 0) {
 547                WOLFSSL_MSG("Error in wc_PKCS7_AddCertificate");
 548                err = 1;
 549            }
 550        }
 551        cert = cert->next;
 552    }
 553
 554    if ((err == 0) && (flags & PKCS7_DETACHED)) {
 555        if (wc_PKCS7_SetDetached(&p7->pkcs7, 1) != 0) {
 556            WOLFSSL_MSG("Failed to set signature detached");
 557            err = 1;
 558        }
 559    }
 560
 561    if ((err == 0) && (flags & PKCS7_STREAM)) {
 562        /* if streaming, return before finalizing */
 563        return (PKCS7*)p7;
 564    }
 565
 566    if ((err == 0) && (wolfSSL_PKCS7_final((PKCS7*)p7, in, flags) != 1)) {
 567        WOLFSSL_MSG("Error calling wolfSSL_PKCS7_final");
 568        err = 1;
 569    }
 570
 571    if ((err != 0) && (p7 != NULL)) {
 572        wolfSSL_PKCS7_free((PKCS7*)p7);
 573        p7 = NULL;
 574    }
 575
 576    return (PKCS7*)p7;
 577}
 578
 579#ifdef HAVE_SMIME
 580
 581#ifndef MAX_MIME_LINE_LEN
 582    #define MAX_MIME_LINE_LEN 1024
 583#endif
 584
 585/**
 586 * Copy input BIO to output BIO, but convert all line endings to CRLF (\r\n),
 587 * used by PKCS7_final().
 588 *
 589 * in  - input WOLFSSL_BIO to be converted
 590 * out - output WOLFSSL_BIO to hold copy of in, with line endings adjusted
 591 *
 592 * Return 0 on success, negative on error
 593 */
 594static int wolfSSL_BIO_to_MIME_crlf(WOLFSSL_BIO* in, WOLFSSL_BIO* out)
 595{
 596    int ret = 0;
 597    int lineLen = 0;
 598    word32 canonLineLen = 0;
 599    char* canonLine = NULL;
 600    WC_DECLARE_VAR(line, char, MAX_MIME_LINE_LEN, 0);
 601
 602    if (in == NULL || out == NULL) {
 603        return BAD_FUNC_ARG;
 604    }
 605
 606#ifdef WOLFSSL_SMALL_STACK
 607    line = (char*)XMALLOC(MAX_MIME_LINE_LEN, in->heap,
 608                          DYNAMIC_TYPE_TMP_BUFFER);
 609    if (line == NULL) {
 610        return MEMORY_E;
 611    }
 612#endif
 613    XMEMSET(line, 0, MAX_MIME_LINE_LEN);
 614
 615    while ((lineLen = wolfSSL_BIO_gets(in, line, MAX_MIME_LINE_LEN)) > 0) {
 616
 617        if (line[lineLen - 1] == '\r' || line[lineLen - 1] == '\n') {
 618            canonLineLen = (word32)lineLen;
 619            if ((canonLine = wc_MIME_single_canonicalize(
 620                                line, &canonLineLen)) == NULL) {
 621                ret = WOLFSSL_FATAL_ERROR;
 622                break;
 623            }
 624
 625            /* remove trailing null */
 626            if (canonLineLen >= 1 && canonLine[canonLineLen-1] == '\0') {
 627                canonLineLen--;
 628            }
 629
 630            if (wolfSSL_BIO_write(out, canonLine, (int)canonLineLen) < 0) {
 631                ret = WOLFSSL_FATAL_ERROR;
 632                break;
 633            }
 634            XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
 635            canonLine = NULL;
 636        }
 637        else {
 638            /* no line ending in current line, write direct to out */
 639            if (wolfSSL_BIO_write(out, line, lineLen) < 0) {
 640                ret = WOLFSSL_FATAL_ERROR;
 641                break;
 642            }
 643        }
 644    }
 645
 646    XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
 647    WC_FREE_VAR_EX(line, in->heap, DYNAMIC_TYPE_TMP_BUFFER);
 648
 649    return ret;
 650}
 651
 652#endif /* HAVE_SMIME */
 653
 654/* Used by both PKCS7_final() and PKCS7_verify() */
 655static const char contTypeText[] = "Content-Type: text/plain\r\n\r\n";
 656
 657/**
 658 * Finalize PKCS7 structure, currently supports signedData only.
 659 *
 660 * Does not generate final bundle (ie: signedData), but finalizes
 661 * the PKCS7 structure in preparation for a output function to be called next.
 662 *
 663 * pkcs7 - initialized PKCS7 structure, populated with signer, etc
 664 * in    - input data
 665 * flags - flags to control PKCS7 behavior. Other flags except those noted
 666 *         below are ignored:
 667 *
 668 *    PKCS7_BINARY - Do not translate input data to MIME canonical
 669 *                   format (\r\n line endings), thus preventing corruption of
 670 *                   binary content.
 671 *    PKCS7_TEXT   - Prepend MIME headers for text/plain to content.
 672 *
 673 * Returns 1 on success, 0 on error
 674 */
 675int wolfSSL_PKCS7_final(PKCS7* pkcs7, WOLFSSL_BIO* in, int flags)
 676{
 677    int ret = 1;
 678    int memSz = 0;
 679    unsigned char* mem = NULL;
 680    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
 681    WOLFSSL_BIO* data = NULL;
 682
 683    WOLFSSL_ENTER("wolfSSL_PKCS7_final");
 684
 685    if (p7 == NULL || in == NULL) {
 686        WOLFSSL_MSG("Bad input args to PKCS7_final");
 687        ret = 0;
 688    }
 689
 690    if (ret == 1) {
 691        if ((data = wolfSSL_BIO_new(wolfSSL_BIO_s_mem())) == NULL) {
 692            WOLFSSL_MSG("Error in wolfSSL_BIO_new");
 693            ret = 0;
 694        }
 695    }
 696
 697    /* prepend Content-Type header if PKCS7_TEXT */
 698    if ((ret == 1) && (flags & PKCS7_TEXT)) {
 699        if (wolfSSL_BIO_write(data, contTypeText,
 700                              (int)XSTR_SIZEOF(contTypeText)) < 0) {
 701            WOLFSSL_MSG("Error prepending Content-Type header");
 702            ret = 0;
 703        }
 704    }
 705
 706    /* convert line endings to CRLF if !PKCS7_BINARY */
 707    if (ret == 1) {
 708        if (flags & PKCS7_BINARY) {
 709
 710            /* no CRLF conversion, direct copy content */
 711            if ((memSz = wolfSSL_BIO_get_len(in)) <= 0) {
 712                ret = 0;
 713            }
 714            if (ret == 1) {
 715                mem = (unsigned char*)XMALLOC(memSz, in->heap,
 716                                              DYNAMIC_TYPE_TMP_BUFFER);
 717                if (mem == NULL) {
 718                    WOLFSSL_MSG("Failed to allocate memory for input data");
 719                    ret = 0;
 720                }
 721            }
 722
 723            if (ret == 1) {
 724                if (wolfSSL_BIO_read(in, mem, memSz) != memSz) {
 725                    WOLFSSL_MSG("Error reading from input BIO");
 726                    ret = 0;
 727                }
 728                else if (wolfSSL_BIO_write(data, mem, memSz) < 0) {
 729                    ret = 0;
 730                }
 731            }
 732
 733            XFREE(mem, in->heap, DYNAMIC_TYPE_TMP_BUFFER);
 734        }
 735        else {
 736    #ifdef HAVE_SMIME
 737            /* convert content line endings to CRLF */
 738            if (wolfSSL_BIO_to_MIME_crlf(in, data) != 0) {
 739                WOLFSSL_MSG("Error converting line endings to CRLF");
 740                ret = 0;
 741            }
 742            else {
 743                p7->pkcs7.contentCRLF = 1;
 744            }
 745    #else
 746            WOLFSSL_MSG("Without PKCS7_BINARY requires wolfSSL to be built "
 747                        "with HAVE_SMIME");
 748            ret = 0;
 749    #endif
 750        }
 751    }
 752
 753    if ((ret == 1) && ((memSz = wolfSSL_BIO_get_mem_data(data, &mem)) < 0)) {
 754        WOLFSSL_MSG("Error in wolfSSL_BIO_get_mem_data");
 755        ret = 0;
 756    }
 757
 758    if (ret == 1) {
 759        XFREE(p7->data, NULL, DYNAMIC_TYPE_PKCS7);
 760        p7->data = (byte*)XMALLOC(memSz, NULL, DYNAMIC_TYPE_PKCS7);
 761        if (p7->data == NULL) {
 762            ret = 0;
 763        }
 764        else {
 765            XMEMCPY(p7->data, mem, memSz);
 766            p7->len = memSz;
 767        }
 768    }
 769
 770    if (ret == 1) {
 771        p7->pkcs7.content = p7->data;
 772        p7->pkcs7.contentSz = (word32)p7->len;
 773    }
 774
 775    if (data != NULL) {
 776        wolfSSL_BIO_free(data);
 777    }
 778
 779    return ret;
 780}
 781
 782int wolfSSL_PKCS7_verify(PKCS7* pkcs7, WOLFSSL_STACK* certs,
 783        WOLFSSL_X509_STORE* store, WOLFSSL_BIO* in, WOLFSSL_BIO* out, int flags)
 784{
 785    int i, ret = 0;
 786    unsigned char* mem = NULL;
 787    int memSz = 0;
 788    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
 789    int contTypeLen;
 790    WOLFSSL_X509* signer = NULL;
 791    WOLFSSL_STACK* signers = NULL;
 792    X509_STORE_CTX* ctx = NULL;
 793
 794
 795    WOLFSSL_ENTER("wolfSSL_PKCS7_verify");
 796
 797    if (pkcs7 == NULL)
 798        return WOLFSSL_FAILURE;
 799
 800    if (in != NULL) {
 801        if ((memSz = wolfSSL_BIO_get_mem_data(in, &mem)) < 0)
 802            return WOLFSSL_FAILURE;
 803
 804        p7->pkcs7.content = mem;
 805        p7->pkcs7.contentSz = (word32)memSz;
 806    }
 807
 808    /* certs is the list of certificates to find the cert with issuer/serial. */
 809    (void)certs;
 810    /* store is the certificate store to use to verify signer certificate
 811     * associated with the signers.
 812     */
 813    (void)store;
 814
 815    ret = wc_PKCS7_VerifySignedData(&p7->pkcs7, p7->data, p7->len);
 816    if (ret != 0)
 817        return WOLFSSL_FAILURE;
 818
 819    if ((flags & PKCS7_NOVERIFY) != PKCS7_NOVERIFY) {
 820        /* Verify signer certificates */
 821        if (store == NULL || store->cm == NULL) {
 822            WOLFSSL_MSG("No store or store certs, but PKCS7_NOVERIFY not set");
 823            return WOLFSSL_FAILURE;
 824        }
 825
 826        ctx = X509_STORE_CTX_new();
 827        if (ctx == NULL) {
 828            WOLFSSL_MSG("Error allocating X509 Store Context");
 829            return WOLFSSL_FAILURE;
 830        }
 831
 832        signers = wolfSSL_PKCS7_get0_signers(pkcs7, certs, flags);
 833        if (signers == NULL) {
 834            WOLFSSL_MSG("No signers found to verify");
 835            wolfSSL_X509_STORE_CTX_free(ctx);
 836            return WOLFSSL_FAILURE;
 837        }
 838
 839        for (i = 0; i < wolfSSL_sk_X509_num(signers); i++) {
 840            signer = wolfSSL_sk_X509_value(signers, i);
 841            if (wolfSSL_X509_STORE_CTX_init(ctx, store, signer, NULL)
 842                        != WOLFSSL_SUCCESS) {
 843                WOLFSSL_MSG("Failed to initialize X509 STORE CTX");
 844                wolfSSL_sk_X509_pop_free(signers, NULL);
 845                wolfSSL_X509_STORE_CTX_free(ctx);
 846                return WOLFSSL_FAILURE;
 847            }
 848            if (wolfSSL_X509_verify_cert(ctx) != WOLFSSL_SUCCESS) {
 849                WOLFSSL_MSG("Failed to verify signer certificate");
 850                wolfSSL_sk_X509_pop_free(signers, NULL);
 851                wolfSSL_X509_STORE_CTX_free(ctx);
 852                return WOLFSSL_FAILURE;
 853            }
 854        }
 855        wolfSSL_sk_X509_pop_free(signers, NULL);
 856        wolfSSL_X509_STORE_CTX_free(ctx);
 857    }
 858
 859    if (flags & PKCS7_TEXT) {
 860        /* strip MIME header for text/plain, otherwise error */
 861        contTypeLen = XSTR_SIZEOF(contTypeText);
 862        if ((p7->pkcs7.contentSz < (word32)contTypeLen) ||
 863            (XMEMCMP(p7->pkcs7.content, contTypeText, contTypeLen) != 0)) {
 864            WOLFSSL_MSG("Error PKCS7 Content-Type not found with PKCS7_TEXT");
 865            return WOLFSSL_FAILURE;
 866        }
 867        p7->pkcs7.content += contTypeLen;
 868        p7->pkcs7.contentSz -= contTypeLen;
 869    }
 870
 871    if (out != NULL) {
 872        wolfSSL_BIO_write(out, p7->pkcs7.content, p7->pkcs7.contentSz);
 873    }
 874
 875    WOLFSSL_LEAVE("wolfSSL_PKCS7_verify", WOLFSSL_SUCCESS);
 876
 877    return WOLFSSL_SUCCESS;
 878}
 879
 880/**
 881 * This API was added as a helper function for libest. It
 882 * encodes a stack of certificates to pkcs7 format.
 883 * @param pkcs7 PKCS7 parameter object
 884 * @param certs WOLFSSL_STACK_OF(WOLFSSL_X509)*
 885 * @param out   Output bio
 886 * @return WOLFSSL_SUCCESS on success and WOLFSSL_FAILURE on failure
 887 */
 888int wolfSSL_PKCS7_encode_certs(PKCS7* pkcs7, WOLFSSL_STACK* certs,
 889        WOLFSSL_BIO* out)
 890{
 891    int ret;
 892    WOLFSSL_PKCS7* p7;
 893    WOLFSSL_ENTER("wolfSSL_PKCS7_encode_certs");
 894
 895    if (!pkcs7 || !certs || !out) {
 896        WOLFSSL_MSG("Bad parameter");
 897        return WOLFSSL_FAILURE;
 898    }
 899
 900    p7 = (WOLFSSL_PKCS7*)pkcs7;
 901
 902    /* take ownership of certs */
 903    p7->certs = certs;
 904    /* TODO: takes ownership even on failure below but not on above failure. */
 905
 906    if (pkcs7->certList) {
 907        WOLFSSL_MSG("wolfSSL_PKCS7_encode_certs called multiple times on same "
 908                    "struct");
 909        return WOLFSSL_FAILURE;
 910    }
 911
 912    if (certs) {
 913        /* Save some of the values */
 914        int hashOID = pkcs7->hashOID;
 915        byte version = pkcs7->version;
 916
 917        if (!certs->data.x509 || !certs->data.x509->derCert) {
 918            WOLFSSL_MSG("Missing cert");
 919            return WOLFSSL_FAILURE;
 920        }
 921
 922        if (wc_PKCS7_InitWithCert(pkcs7, certs->data.x509->derCert->buffer,
 923                                      certs->data.x509->derCert->length) != 0) {
 924            WOLFSSL_MSG("wc_PKCS7_InitWithCert error");
 925            return WOLFSSL_FAILURE;
 926        }
 927        certs = certs->next;
 928
 929        pkcs7->hashOID = hashOID;
 930        pkcs7->version = version;
 931    }
 932
 933    /* Add the certs to the PKCS7 struct */
 934    while (certs) {
 935        if (!certs->data.x509 || !certs->data.x509->derCert) {
 936            WOLFSSL_MSG("Missing cert");
 937            return WOLFSSL_FAILURE;
 938        }
 939        if (wc_PKCS7_AddCertificate(pkcs7, certs->data.x509->derCert->buffer,
 940                                      certs->data.x509->derCert->length) != 0) {
 941            WOLFSSL_MSG("wc_PKCS7_AddCertificate error");
 942            return WOLFSSL_FAILURE;
 943        }
 944        certs = certs->next;
 945    }
 946
 947    if (wc_PKCS7_SetSignerIdentifierType(pkcs7, DEGENERATE_SID) != 0) {
 948        WOLFSSL_MSG("wc_PKCS7_SetSignerIdentifierType error");
 949        return WOLFSSL_FAILURE;
 950    }
 951
 952    ret = wolfSSL_i2d_PKCS7_bio(out, pkcs7);
 953
 954    return ret;
 955}
 956
 957/******************************************************************************
 958* wolfSSL_PEM_write_bio_PKCS7 - writes the PKCS7 data to BIO
 959*
 960* RETURNS:
 961* returns WOLFSSL_SUCCESS on success, otherwise returns WOLFSSL_FAILURE
 962*/
 963int wolfSSL_PEM_write_bio_PKCS7(WOLFSSL_BIO* bio, PKCS7* p7)
 964{
 965#ifdef WOLFSSL_SMALL_STACK
 966    byte* outputHead;
 967    byte* outputFoot;
 968#else
 969    byte outputHead[2048];
 970    byte outputFoot[2048];
 971#endif
 972    word32 outputHeadSz = 2048;
 973    word32 outputFootSz = 2048;
 974    word32 outputSz = 0;
 975    byte*  output = NULL;
 976    byte*  pem = NULL;
 977    int    pemSz = -1;
 978    enum wc_HashType hashType;
 979    byte hashBuf[WC_MAX_DIGEST_SIZE];
 980    word32 hashSz = 0;
 981
 982    WOLFSSL_ENTER("wolfSSL_PEM_write_bio_PKCS7");
 983
 984    if (bio == NULL || p7 == NULL)
 985        return WOLFSSL_FAILURE;
 986
 987#ifdef WOLFSSL_SMALL_STACK
 988    outputHead = (byte*)XMALLOC(outputHeadSz, bio->heap,
 989        DYNAMIC_TYPE_TMP_BUFFER);
 990    if (outputHead == NULL)
 991        return MEMORY_E;
 992
 993    outputFoot = (byte*)XMALLOC(outputFootSz, bio->heap,
 994        DYNAMIC_TYPE_TMP_BUFFER);
 995    if (outputFoot == NULL)
 996        goto error;
 997
 998#endif
 999
1000    XMEMSET(hashBuf, 0, WC_MAX_DIGEST_SIZE);
1001    XMEMSET(outputHead, 0, outputHeadSz);
1002    XMEMSET(outputFoot, 0, outputFootSz);
1003
1004    hashType = wc_OidGetHash(p7->hashOID);
1005    hashSz = (word32)wc_HashGetDigestSize(hashType);
1006    if (hashSz > WC_MAX_DIGEST_SIZE)
1007        goto error;
1008
1009    /* only SIGNED_DATA is supported */
1010    switch (p7->contentOID) {
1011        case SIGNED_DATA:
1012            break;
1013        default:
1014            WOLFSSL_MSG("Unknown PKCS#7 Type");
1015            goto error;
1016    };
1017
1018    if ((wc_PKCS7_EncodeSignedData_ex(p7, hashBuf, hashSz,
1019        outputHead, &outputHeadSz, outputFoot, &outputFootSz)) != 0)
1020        goto error;
1021
1022    outputSz = outputHeadSz + p7->contentSz + outputFootSz;
1023    output = (byte*)XMALLOC(outputSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1024
1025    if (!output)
1026        goto error;
1027
1028    XMEMSET(output, 0, outputSz);
1029    outputSz = 0;
1030    XMEMCPY(&output[outputSz], outputHead, outputHeadSz);
1031    outputSz += outputHeadSz;
1032    XMEMCPY(&output[outputSz], p7->content, p7->contentSz);
1033    outputSz += p7->contentSz;
1034    XMEMCPY(&output[outputSz], outputFoot, outputFootSz);
1035    outputSz += outputFootSz;
1036
1037    /* get PEM size */
1038    pemSz = wc_DerToPemEx(output, outputSz, NULL, 0, NULL, CERT_TYPE);
1039    if (pemSz < 0)
1040        goto error;
1041
1042    pemSz++; /* for '\0'*/
1043
1044    /* create PEM buffer and convert from DER to PEM*/
1045    if ((pem = (byte*)XMALLOC(pemSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER))
1046                                                                        == NULL)
1047        goto error;
1048
1049    XMEMSET(pem, 0, pemSz);
1050
1051    if (wc_DerToPemEx(output, outputSz, pem, (word32)pemSz, NULL,CERT_TYPE)
1052                                                                          < 0) {
1053        goto error;
1054    }
1055    if ((wolfSSL_BIO_write(bio, pem, pemSz) == pemSz)) {
1056        XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1057        XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1058        WC_FREE_VAR_EX(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1059        WC_FREE_VAR_EX(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1060        return WOLFSSL_SUCCESS;
1061    }
1062
1063error:
1064    WC_FREE_VAR_EX(outputHead, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1065    WC_FREE_VAR_EX(outputFoot, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1066    XFREE(output, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1067    XFREE(pem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1068    return WOLFSSL_FAILURE;
1069}
1070
1071#ifdef HAVE_SMIME
1072/*****************************************************************************
1073* wolfSSL_SMIME_read_PKCS7 - Reads the given S/MIME message and parses it into
1074* a PKCS7 object. In case of a multipart message, stores the signed data in
1075* bcont.
1076*
1077* RETURNS:
1078* returns pointer to a PKCS7 structure on success, otherwise returns NULL
1079*/
1080PKCS7* wolfSSL_SMIME_read_PKCS7(WOLFSSL_BIO* in,
1081        WOLFSSL_BIO** bcont)
1082{
1083    MimeHdr* allHdrs = NULL;
1084    MimeHdr* curHdr = NULL;
1085    MimeParam* curParam = NULL;
1086    int inLen = 0;
1087    byte* bcontMem = NULL;
1088    int bcontMemSz = 0;
1089    int sectionLen = 0;
1090    int ret = -1;
1091    char* section = NULL;
1092    char* canonLine = NULL;
1093    char* canonSection = NULL;
1094    PKCS7* pkcs7 = NULL;
1095    word32 outLen = 0;
1096    word32 canonLineLen = 0;
1097    byte* out = NULL;
1098    byte* outHead = NULL;
1099
1100    int canonPos = 0;
1101    int lineLen = 0;
1102    int remainLen = 0;
1103    byte isEnd = 0;
1104    size_t canonSize = 0;
1105    size_t boundLen = 0;
1106    char* boundary = NULL;
1107
1108    static const char kContType[] = "Content-Type";
1109    static const char kCTE[] = "Content-Transfer-Encoding";
1110    static const char kMultSigned[] = "multipart/signed";
1111    static const char kAppPkcsSign[] = "application/pkcs7-signature";
1112    static const char kAppXPkcsSign[] = "application/x-pkcs7-signature";
1113    static const char kAppPkcs7Mime[] = "application/pkcs7-mime";
1114    static const char kAppXPkcs7Mime[] = "application/x-pkcs7-mime";
1115
1116    WOLFSSL_ENTER("wolfSSL_SMIME_read_PKCS7");
1117
1118    if (in == NULL || bcont == NULL) {
1119        goto error;
1120    }
1121    inLen = wolfSSL_BIO_get_len(in);
1122    if (inLen <= 0) {
1123        goto error;
1124    }
1125    remainLen = wolfSSL_BIO_get_len(in);
1126    if (remainLen <= 0) {
1127        goto error;
1128    }
1129
1130    section = (char*)XMALLOC(remainLen+1, NULL, DYNAMIC_TYPE_PKCS7);
1131    if (section == NULL) {
1132        goto error;
1133    }
1134    lineLen = wolfSSL_BIO_gets(in, section, remainLen);
1135    if (lineLen <= 0) {
1136        goto error;
1137    }
1138    while (isEnd == 0 && remainLen > 0) {
1139        sectionLen += lineLen;
1140        remainLen -= lineLen;
1141        lineLen = wolfSSL_BIO_gets(in, &section[sectionLen], remainLen);
1142        if (lineLen <= 0) {
1143            goto error;
1144        }
1145        /* Line with just newline signals end of headers. */
1146        if ((lineLen==2 && !XSTRNCMP(&section[sectionLen],
1147                                     "\r\n", 2)) ||
1148            (lineLen==1 && (section[sectionLen] == '\r' ||
1149                            section[sectionLen] == '\n'))) {
1150            isEnd = 1;
1151        }
1152    }
1153    section[sectionLen] = '\0';
1154    ret = wc_MIME_parse_headers(section, sectionLen, &allHdrs);
1155    if (ret < 0) {
1156        WOLFSSL_MSG("Parsing MIME headers failed.");
1157        goto error;
1158    }
1159    isEnd = 0;
1160    section[0] = '\0';
1161    sectionLen = 0;
1162
1163    curHdr = wc_MIME_find_header_name(kContType, allHdrs);
1164    if (curHdr && !XSTRNCMP(curHdr->body, kMultSigned,
1165                            XSTR_SIZEOF(kMultSigned))) {
1166        curParam = wc_MIME_find_param_attr("protocol", curHdr->params);
1167        if (curParam && (!XSTRNCMP(curParam->value, kAppPkcsSign,
1168                                   XSTR_SIZEOF(kAppPkcsSign)) ||
1169                         !XSTRNCMP(curParam->value, kAppXPkcsSign,
1170                                   XSTR_SIZEOF(kAppXPkcsSign)))) {
1171            curParam = wc_MIME_find_param_attr("boundary", curHdr->params);
1172            if (curParam == NULL) {
1173                goto error;
1174            }
1175
1176            boundLen = XSTRLEN(curParam->value) + 2;
1177            boundary = (char*)XMALLOC(boundLen+1, NULL, DYNAMIC_TYPE_PKCS7);
1178            if (boundary == NULL) {
1179                goto error;
1180            }
1181            XMEMSET(boundary, 0, (word32)(boundLen+1));
1182            boundary[0] = boundary[1] = '-';
1183            /* analyzers have issues with using strncpy and strcpy here */
1184            XMEMCPY(&boundary[2], curParam->value, boundLen - 2);
1185
1186            /* Parse up to first boundary, ignore everything here. */
1187            lineLen = wolfSSL_BIO_gets(in, section, remainLen);
1188            if (lineLen <= 0) {
1189                goto error;
1190            }
1191            while (XSTRNCMP(&section[sectionLen], boundary, boundLen) &&
1192                   remainLen > 0) {
1193                sectionLen += lineLen;
1194                remainLen -= lineLen;
1195                lineLen = wolfSSL_BIO_gets(in, &section[sectionLen],
1196                                           remainLen);
1197                if (lineLen <= 0) {
1198                    goto error;
1199                }
1200            }
1201
1202            section[0] = '\0';
1203            sectionLen = 0;
1204            canonSize = (size_t)remainLen + 1;
1205            canonSection = (char*)XMALLOC(canonSize, NULL,
1206                                          DYNAMIC_TYPE_PKCS7);
1207            if (canonSection == NULL) {
1208                goto error;
1209            } else {
1210                XMEMSET(canonSection, 0, (word32)canonSize);
1211            }
1212
1213            lineLen = wolfSSL_BIO_gets(in, section, remainLen);
1214            if (lineLen < 0) {
1215                goto error;
1216            }
1217            while (XSTRNCMP(&section[sectionLen], boundary, boundLen) &&
1218                            remainLen > 0) {
1219                canonLineLen = (word32)lineLen;
1220                canonLine = wc_MIME_single_canonicalize(&section[sectionLen],
1221                                                        &canonLineLen);
1222                if (canonLine == NULL) {
1223                    goto error;
1224                }
1225                /* If line endings were added, the initial length may be
1226                 * exceeded. */
1227                if ((canonPos + canonLineLen) >= canonSize) {
1228                    char* newCanonSection;
1229                    canonSize = canonPos + canonLineLen;
1230                    newCanonSection = (char*)XREALLOC(canonSection, canonSize,
1231                                                   NULL, DYNAMIC_TYPE_PKCS7);
1232                    if (newCanonSection == NULL) {
1233                        goto error;
1234                    }
1235                    canonSection = newCanonSection;
1236                }
1237                XMEMCPY(&canonSection[canonPos], canonLine,
1238                        (int)canonLineLen - 1);
1239                canonPos += canonLineLen - 1;
1240                XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
1241                canonLine = NULL;
1242
1243                sectionLen += lineLen;
1244                remainLen -= lineLen;
1245
1246                lineLen = wolfSSL_BIO_gets(in, &section[sectionLen],
1247                                           remainLen);
1248                if (lineLen <= 0) {
1249                    goto error;
1250                }
1251            }
1252
1253            if (canonPos > 0) {
1254                canonPos--;
1255            }
1256
1257            /* Strip the final trailing newline.  Support \r, \n or \r\n. */
1258            if (canonSection[canonPos] == '\n') {
1259                if (canonPos > 0) {
1260                    canonPos--;
1261                }
1262            }
1263
1264            if (canonSection[canonPos] == '\r') {
1265                if (canonPos > 0) {
1266                    canonPos--;
1267                }
1268            }
1269
1270            canonSection[canonPos+1] = '\0';
1271
1272            *bcont = wolfSSL_BIO_new(wolfSSL_BIO_s_mem());
1273            ret = wolfSSL_BIO_write(*bcont, canonSection,
1274                                    canonPos + 1);
1275            if (ret != (canonPos+1)) {
1276                goto error;
1277            }
1278            if ((bcontMemSz = wolfSSL_BIO_get_mem_data(*bcont, &bcontMem))
1279                                                                          < 0) {
1280                goto error;
1281            }
1282            XFREE(canonSection, NULL, DYNAMIC_TYPE_PKCS7);
1283            canonSection = NULL;
1284
1285            wc_MIME_free_hdrs(allHdrs);
1286            allHdrs = NULL;
1287            section[0] = '\0';
1288            sectionLen = 0;
1289            lineLen = wolfSSL_BIO_gets(in, section, remainLen);
1290            if (lineLen <= 0) {
1291                goto error;
1292            }
1293            while (isEnd == 0 && remainLen > 0) {
1294                sectionLen += lineLen;
1295                remainLen -= lineLen;
1296                lineLen = wolfSSL_BIO_gets(in, &section[sectionLen],
1297                                           remainLen);
1298                if (lineLen <= 0) {
1299                    goto error;
1300                }
1301                /* Line with just newline signals end of headers. */
1302                if ((lineLen==2 && !XSTRNCMP(&section[sectionLen],
1303                                             "\r\n", 2)) ||
1304                    (lineLen==1 && (section[sectionLen] == '\r' ||
1305                                    section[sectionLen] == '\n'))) {
1306                    isEnd = 1;
1307                }
1308            }
1309            section[sectionLen] = '\0';
1310            ret = wc_MIME_parse_headers(section, sectionLen, &allHdrs);
1311            if (ret < 0) {
1312                WOLFSSL_MSG("Parsing MIME headers failed.");
1313                goto error;
1314            }
1315            curHdr = wc_MIME_find_header_name(kContType, allHdrs);
1316            if (curHdr == NULL || (XSTRNCMP(curHdr->body, kAppPkcsSign,
1317                                   XSTR_SIZEOF(kAppPkcsSign)) &&
1318                                   XSTRNCMP(curHdr->body, kAppXPkcsSign,
1319                                   XSTR_SIZEOF(kAppXPkcsSign)))) {
1320                WOLFSSL_MSG("S/MIME headers not found inside "
1321                            "multipart message.\n");
1322                goto error;
1323            }
1324
1325            section[0] = '\0';
1326            sectionLen = 0;
1327            lineLen = wolfSSL_BIO_gets(in, section, remainLen);
1328            while (XSTRNCMP(&section[sectionLen], boundary, boundLen) &&
1329                   remainLen > 0) {
1330                sectionLen += lineLen;
1331                remainLen -= lineLen;
1332                lineLen = wolfSSL_BIO_gets(in, &section[sectionLen],
1333                                           remainLen);
1334                if (lineLen <= 0) {
1335                    goto error;
1336                }
1337            }
1338
1339            XFREE(boundary, NULL, DYNAMIC_TYPE_PKCS7);
1340            boundary = NULL;
1341        }
1342    }
1343    else if (curHdr && (!XSTRNCMP(curHdr->body, kAppPkcs7Mime,
1344                                  XSTR_SIZEOF(kAppPkcs7Mime)) ||
1345                        !XSTRNCMP(curHdr->body, kAppXPkcs7Mime,
1346                                  XSTR_SIZEOF(kAppXPkcs7Mime)))) {
1347        sectionLen = wolfSSL_BIO_get_len(in);
1348        if (sectionLen <= 0) {
1349            goto error;
1350        }
1351        ret = wolfSSL_BIO_read(in, section, sectionLen);
1352        if (ret < 0 || ret != sectionLen) {
1353            WOLFSSL_MSG("Error reading input BIO.");
1354            goto error;
1355        }
1356    }
1357    else {
1358        WOLFSSL_MSG("S/MIME headers not found.");
1359        goto error;
1360    }
1361
1362    curHdr = wc_MIME_find_header_name(kCTE, allHdrs);
1363    if (curHdr == NULL) {
1364        WOLFSSL_MSG("Content-Transfer-Encoding header not found, "
1365                    "assuming base64 encoding.");
1366    }
1367    else if (XSTRNCMP(curHdr->body, "base64", XSTRLEN("base64"))) {
1368        WOLFSSL_MSG("S/MIME encodings other than base64 are not "
1369                    "currently supported.\n");
1370        goto error;
1371    }
1372
1373    if (section == NULL || sectionLen <= 0) {
1374        goto error;
1375    }
1376    outLen = (word32)((sectionLen*3+3)/4)+1;
1377    out = (byte*)XMALLOC(outLen*sizeof(byte), NULL, DYNAMIC_TYPE_PKCS7);
1378    outHead = out;
1379    if (outHead == NULL) {
1380        goto error;
1381    }
1382    /* Strip trailing newlines. */
1383    while ((sectionLen > 0) &&
1384           (section[sectionLen-1] == '\r' || section[sectionLen-1] == '\n')) {
1385        sectionLen--;
1386    }
1387    section[sectionLen] = '\0';
1388    ret = Base64_Decode((const byte*)section, (word32)sectionLen, out, &outLen);
1389    if (ret < 0) {
1390        WOLFSSL_MSG("Error base64 decoding S/MIME message.");
1391        goto error;
1392    }
1393    pkcs7 = wolfSSL_d2i_PKCS7_only(NULL, (const unsigned char**)&out,
1394        (int)outLen, bcontMem, (word32)bcontMemSz);
1395
1396    wc_MIME_free_hdrs(allHdrs);
1397    XFREE(outHead, NULL, DYNAMIC_TYPE_PKCS7);
1398    XFREE(section, NULL, DYNAMIC_TYPE_PKCS7);
1399
1400    return pkcs7;
1401
1402error:
1403    wc_MIME_free_hdrs(allHdrs);
1404    XFREE(boundary, NULL, DYNAMIC_TYPE_PKCS7);
1405    XFREE(outHead, NULL, DYNAMIC_TYPE_PKCS7);
1406    XFREE(section, NULL, DYNAMIC_TYPE_PKCS7);
1407    XFREE(canonSection, NULL, DYNAMIC_TYPE_PKCS7);
1408    XFREE(canonLine, NULL, DYNAMIC_TYPE_PKCS7);
1409    if (bcont) {
1410        wolfSSL_BIO_free(*bcont);
1411        *bcont = NULL; /* reset 'bcount' pointer to NULL on failure */
1412    }
1413
1414    return NULL;
1415}
1416
1417/* Convert hash algo OID (from Hash_Sum in asn.h) to SMIME string equivalent.
1418 * Returns hash algorithm string or "unknown" if not found */
1419static const char* wolfSSL_SMIME_HashOIDToString(int hashOID)
1420{
1421    switch (hashOID) {
1422        case MD5h:
1423            return "md5";
1424        case SHAh:
1425            return "sha1";
1426        case SHA224h:
1427            return "sha-224";
1428        case SHA256h:
1429            return "sha-256";
1430        case SHA384h:
1431            return "sha-384";
1432        case SHA512h:
1433            return "sha-512";
1434        case SHA3_224h:
1435            return "sha3-224";
1436        case SHA3_384h:
1437            return "sha3-384";
1438        case SHA3_512h:
1439            return "sha3-512";
1440        default:
1441            break;
1442    }
1443
1444    return "unknown";
1445}
1446
1447/* Convert PKCS#7 type (from PKCS7_TYPES in pkcs7.h) to SMIME string.
1448 * RFC2633 only defines signed-data, enveloped-data, certs-only.
1449 * Returns string on success, NULL on unknown type. */
1450static const char* wolfSSL_SMIME_PKCS7TypeToString(int type)
1451{
1452    switch (type) {
1453        case SIGNED_DATA:
1454            return "signed-data";
1455        case ENVELOPED_DATA:
1456            return "enveloped-data";
1457        default:
1458            break;
1459    }
1460
1461    return NULL;
1462}
1463
1464/**
1465 * Convert PKCS7 structure to SMIME format, adding necessary headers.
1466 *
1467 * Handles generation of PKCS7 bundle (ie: signedData). PKCS7 structure
1468 * should be set up beforehand with PKCS7_sign/final/etc. Output is always
1469 * Base64 encoded.
1470 *
1471 * out   - output BIO for SMIME formatted data to be placed
1472 * pkcs7 - input PKCS7 structure, initialized and set up
1473 * in    - input content to be encoded into PKCS7
1474 * flags - flags to control behavior of PKCS7 generation
1475 *
1476 * Returns 1 on success, 0 or negative on failure
1477 */
1478int wolfSSL_SMIME_write_PKCS7(WOLFSSL_BIO* out, PKCS7* pkcs7, WOLFSSL_BIO* in,
1479                              int flags)
1480{
1481    int i;
1482    int ret = 1;
1483    WOLFSSL_PKCS7* p7 = (WOLFSSL_PKCS7*)pkcs7;
1484    byte* p7out = NULL;
1485    int len = 0;
1486
1487    char boundary[33]; /* 32 chars + \0 */
1488    byte* sigBase64 = NULL;
1489    word32 sigBase64Len = 0;
1490    const char* p7TypeString = NULL;
1491
1492    static const char alphanum[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
1493
1494    if (out == NULL || p7 == NULL) {
1495        WOLFSSL_MSG("Bad function arguments");
1496        return 0;
1497    }
1498
1499    if (in != NULL && (p7->pkcs7.content == NULL || p7->pkcs7.contentSz == 0 ||
1500                       p7->pkcs7.contentCRLF == 0)) {
1501        /* store and adjust content line endings for CRLF if needed */
1502        if (wolfSSL_PKCS7_final((PKCS7*)p7, in, flags) != 1) {
1503            ret = 0;
1504        }
1505    }
1506
1507    if (ret > 0) {
1508        /* Generate signedData bundle, DER in output (dynamic) */
1509        if ((len = wolfSSL_i2d_PKCS7((PKCS7*)p7, &p7out)) ==
1510            WC_NO_ERR_TRACE(WOLFSSL_FAILURE))
1511        {
1512            WOLFSSL_MSG("Error in wolfSSL_i2d_PKCS7");
1513            ret = 0;
1514        }
1515    }
1516
1517    /* Base64 encode signedData bundle */
1518    if (ret > 0) {
1519        if (Base64_Encode(p7out, (word32)len, NULL, &sigBase64Len) !=
1520            WC_NO_ERR_TRACE(LENGTH_ONLY_E)) {
1521            ret = 0;
1522        }
1523        else {
1524            sigBase64 = (byte*)XMALLOC(sigBase64Len, NULL,
1525                                       DYNAMIC_TYPE_TMP_BUFFER);
1526            if (sigBase64 == NULL) {
1527                ret = 0;
1528            }
1529        }
1530    }
1531
1532    if (ret > 0) {
1533        XMEMSET(sigBase64, 0, sigBase64Len);
1534        if (Base64_Encode(p7out, (word32)len, sigBase64, &sigBase64Len) < 0) {
1535            WOLFSSL_MSG("Error in Base64_Encode of signature");
1536            ret = 0;
1537        }
1538    }
1539
1540    /* build up SMIME message */
1541    if (ret > 0) {
1542        if (flags & PKCS7_DETACHED) {
1543
1544            /* generate random boundary */
1545            if (initGlobalRNG == 0 && wolfSSL_RAND_Init() != WOLFSSL_SUCCESS) {
1546                WOLFSSL_MSG("No RNG to use");
1547                ret = 0;
1548            }
1549
1550            /* no need to generate random byte for null terminator (size-1) */
1551            if ((ret > 0) && (wc_RNG_GenerateBlock(&globalRNG, (byte*)boundary,
1552                                  sizeof(boundary) - 1 ) != 0)) {
1553                    WOLFSSL_MSG("Error in wc_RNG_GenerateBlock");
1554                    ret = 0;
1555            }
1556
1557            if (ret > 0) {
1558                for (i = 0; i < (int)sizeof(boundary) - 1; i++) {
1559                    boundary[i] =
1560                        alphanum[boundary[i] % XSTR_SIZEOF(alphanum)];
1561                }
1562                boundary[sizeof(boundary)-1] = 0;
1563            }
1564
1565            if (ret > 0) {
1566                /* S/MIME header beginning */
1567                ret = wolfSSL_BIO_printf(out,
1568                        "MIME-Version: 1.0\n"
1569                        "Content-Type: multipart/signed; "
1570                        "protocol=\"application/x-pkcs7-signature\"; "
1571                        "micalg=\"%s\"; "
1572                        "boundary=\"----%s\"\n\n"
1573                        "This is an S/MIME signed message\n\n"
1574                        "------%s\n",
1575                        wolfSSL_SMIME_HashOIDToString(p7->pkcs7.hashOID),
1576                        boundary, boundary);
1577            }
1578
1579            if (ret > 0) {
1580                /* S/MIME content */
1581                ret = wolfSSL_BIO_write(out,
1582                        p7->pkcs7.content, p7->pkcs7.contentSz);
1583            }
1584
1585            if (ret > 0) {
1586                /* S/SMIME header end boundary */
1587                ret = wolfSSL_BIO_printf(out,
1588                        "\n------%s\n", boundary);
1589            }
1590
1591            if (ret > 0) {
1592                /* Signature and header */
1593                ret = wolfSSL_BIO_printf(out,
1594                        "Content-Type: application/x-pkcs7-signature; "
1595                        "name=\"smime.p7s\"\n"
1596                        "Content-Transfer-Encoding: base64\n"
1597                        "Content-Disposition: attachment; "
1598                        "filename=\"smime.p7s\"\n\n"
1599                        "%.*s\n" /* Base64 encoded signature */
1600                        "------%s--\n\n",
1601                        sigBase64Len, sigBase64,
1602                        boundary);
1603            }
1604        }
1605        else {
1606            p7TypeString = wolfSSL_SMIME_PKCS7TypeToString(p7->type);
1607            if (p7TypeString == NULL) {
1608                WOLFSSL_MSG("Unsupported PKCS7 SMIME type");
1609                ret = 0;
1610            }
1611
1612            if (ret > 0) {
1613                /* not detached */
1614                ret = wolfSSL_BIO_printf(out,
1615                        "MIME-Version: 1.0\n"
1616                        "Content-Disposition: attachment; "
1617                        "filename=\"smime.p7m\"\n"
1618                        "Content-Type: application/x-pkcs7-mime; "
1619                        "smime-type=%s; name=\"smime.p7m\"\n"
1620                        "Content-Transfer-Encoding: base64\n\n"
1621                        "%.*s\n" /* signature */,
1622                        p7TypeString, sigBase64Len, sigBase64);
1623            }
1624        }
1625    }
1626
1627    XFREE(p7out, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1628    XFREE(sigBase64, NULL, DYNAMIC_TYPE_TMP_BUFFER);
1629
1630    if (ret > 0) {
1631        return WOLFSSL_SUCCESS;
1632    }
1633
1634    return WOLFSSL_FAILURE;
1635}
1636
1637#endif /* HAVE_SMIME */
1638#endif /* !NO_BIO */
1639#endif /* OPENSSL_ALL */
1640
1641#endif /* HAVE_PKCS7 */
1642/*******************************************************************************
1643 * END OF PKCS7 APIs
1644 ******************************************************************************/
1645
1646/*******************************************************************************
1647 * START OF PKCS12 APIs
1648 ******************************************************************************/
1649#ifdef OPENSSL_EXTRA
1650
1651/* no-op function. Was initially used for adding encryption algorithms available
1652 * for PKCS12 */
1653void wolfSSL_PKCS12_PBE_add(void)
1654{
1655    WOLFSSL_ENTER("wolfSSL_PKCS12_PBE_add");
1656}
1657
1658#if !defined(NO_FILESYSTEM) && !defined(NO_STDIO_FILESYSTEM)
1659WOLFSSL_X509_PKCS12 *wolfSSL_d2i_PKCS12_fp(XFILE fp,
1660        WOLFSSL_X509_PKCS12 **pkcs12)
1661{
1662    WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_fp");
1663    return (WOLFSSL_X509_PKCS12 *)wolfSSL_d2i_X509_fp_ex(fp, (void **)pkcs12,
1664        PKCS12_TYPE);
1665}
1666#endif /* !NO_FILESYSTEM */
1667
1668#endif /* OPENSSL_EXTRA */
1669
1670#if defined(HAVE_PKCS12)
1671
1672#ifdef OPENSSL_EXTRA
1673
1674#if !defined(NO_ASN) && !defined(NO_PWDBASED)
1675
1676#ifndef NO_BIO
1677WC_PKCS12* wolfSSL_d2i_PKCS12_bio(WOLFSSL_BIO* bio, WC_PKCS12** pkcs12)
1678{
1679    WC_PKCS12* localPkcs12 = NULL;
1680    unsigned char* mem = NULL;
1681    long memSz;
1682    int ret = -1;
1683
1684    WOLFSSL_ENTER("wolfSSL_d2i_PKCS12_bio");
1685
1686    if (bio == NULL) {
1687        WOLFSSL_MSG("Bad Function Argument bio is NULL");
1688        return NULL;
1689    }
1690
1691    memSz = wolfSSL_BIO_get_len(bio);
1692    if (memSz <= 0) {
1693        return NULL;
1694    }
1695    mem = (unsigned char*)XMALLOC(memSz, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1696    if (mem == NULL) {
1697        return NULL;
1698    }
1699
1700    if (mem != NULL) {
1701        localPkcs12 = wc_PKCS12_new_ex(bio->heap);
1702        if (localPkcs12 == NULL) {
1703            WOLFSSL_MSG("Memory error");
1704        }
1705    }
1706
1707    if (mem != NULL && localPkcs12 != NULL) {
1708        if (wolfSSL_BIO_read(bio, mem, (int)memSz) == memSz) {
1709            ret = wc_d2i_PKCS12(mem, (word32)memSz, localPkcs12);
1710            if (ret < 0) {
1711                WOLFSSL_MSG("Failed to get PKCS12 sequence");
1712            }
1713        }
1714        else {
1715            WOLFSSL_MSG("Failed to get data from bio struct");
1716        }
1717    }
1718
1719    /* cleanup */
1720    XFREE(mem, bio->heap, DYNAMIC_TYPE_TMP_BUFFER);
1721    if (ret < 0 && localPkcs12 != NULL) {
1722        wc_PKCS12_free(localPkcs12);
1723        localPkcs12 = NULL;
1724    }
1725    if (pkcs12 != NULL)
1726        *pkcs12 = localPkcs12;
1727
1728    return localPkcs12;
1729}
1730
1731/* Converts the PKCS12 to DER format and outputs it into bio.
1732 *
1733 * bio is the structure to hold output DER
1734 * pkcs12 structure to create DER from
1735 *
1736 * return 1 for success or 0 if an error occurs
1737 */
1738int wolfSSL_i2d_PKCS12_bio(WOLFSSL_BIO *bio, WC_PKCS12 *pkcs12)
1739{
1740    int ret = WC_NO_ERR_TRACE(WOLFSSL_FAILURE);
1741
1742    WOLFSSL_ENTER("wolfSSL_i2d_PKCS12_bio");
1743
1744    if ((bio != NULL) && (pkcs12 != NULL)) {
1745        word32 certSz = 0;
1746        byte *certDer = NULL;
1747
1748        certSz = (word32)wc_i2d_PKCS12(pkcs12, &certDer, NULL);
1749        if ((certSz > 0) && (certDer != NULL)) {
1750            if (wolfSSL_BIO_write(bio, certDer, (int)certSz) == (int)certSz) {
1751                ret = WOLFSSL_SUCCESS;
1752            }
1753        }
1754
1755        XFREE(certDer, NULL, DYNAMIC_TYPE_PKCS);
1756    }
1757
1758    return ret;
1759}
1760#endif /* !NO_BIO */
1761
1762/* Creates a new WC_PKCS12 structure
1763 *
1764 * pass  password to use
1765 * name  friendlyName to use
1766 * pkey  private key to go into PKCS12 bundle
1767 * cert  certificate to go into PKCS12 bundle
1768 * ca    extra certificates that can be added to bundle. Can be NULL
1769 * keyNID  type of encryption to use on the key (-1 means no encryption)
1770 * certNID type of encryption to use on the certificate
1771 * itt     number of iterations with encryption
1772 * macItt  number of iterations with mac creation
1773 * keyType flag for signature and/or encryption key
1774 *
1775 * returns a pointer to a new WC_PKCS12 structure on success and NULL on fail
1776 */
1777WC_PKCS12* wolfSSL_PKCS12_create(char* pass, char* name, WOLFSSL_EVP_PKEY* pkey,
1778        WOLFSSL_X509* cert, WOLF_STACK_OF(WOLFSSL_X509)* ca, int keyNID,
1779        int certNID, int itt, int macItt, int keyType)
1780{
1781    WC_PKCS12* pkcs12;
1782    WC_DerCertList* list = NULL;
1783    word32 passSz;
1784    byte* keyDer = NULL;
1785    word32 keyDerSz;
1786    byte* certDer;
1787    int certDerSz;
1788
1789    WOLFSSL_ENTER("wolfSSL_PKCS12_create");
1790
1791    if (pass == NULL || pkey == NULL || cert == NULL) {
1792        WOLFSSL_LEAVE("wolfSSL_PKCS12_create", BAD_FUNC_ARG);
1793        return NULL;
1794    }
1795    passSz = (word32)XSTRLEN(pass);
1796
1797    keyDer = (byte*)pkey->pkey.ptr;
1798    keyDerSz = (word32)pkey->pkey_sz;
1799
1800    certDer = (byte*)wolfSSL_X509_get_der(cert, &certDerSz);
1801    if (certDer == NULL) {
1802        return NULL;
1803    }
1804
1805    if (ca != NULL) {
1806        unsigned long numCerts = ca->num;
1807        WOLFSSL_STACK* sk = ca;
1808
1809        while (numCerts > 0 && sk != NULL) {
1810            byte* curDer;
1811            WC_DerCertList* cur;
1812            int   curDerSz = 0;
1813
1814            cur = (WC_DerCertList*)XMALLOC(sizeof(WC_DerCertList), NULL,
1815                    DYNAMIC_TYPE_PKCS);
1816            if (cur == NULL) {
1817                wc_FreeCertList(list, NULL);
1818                return NULL;
1819            }
1820
1821            curDer = (byte*)wolfSSL_X509_get_der(sk->data.x509, &curDerSz);
1822            if (curDer == NULL || curDerSz < 0) {
1823                XFREE(cur, NULL, DYNAMIC_TYPE_PKCS);
1824                wc_FreeCertList(list, NULL);
1825                return NULL;
1826            }
1827
1828            cur->buffer = (byte*)XMALLOC(curDerSz, NULL, DYNAMIC_TYPE_PKCS);
1829            if (cur->buffer == NULL) {
1830                XFREE(cur, NULL, DYNAMIC_TYPE_PKCS);
1831                wc_FreeCertList(list, NULL);
1832                return NULL;
1833            }
1834            XMEMCPY(cur->buffer, curDer, curDerSz);
1835            cur->bufferSz = (word32)curDerSz;
1836            cur->next = list;
1837            list = cur;
1838
1839            sk = sk->next;
1840            numCerts--;
1841        }
1842    }
1843
1844    pkcs12 = wc_PKCS12_create(pass, passSz, name, keyDer, keyDerSz,
1845            certDer, (word32)certDerSz, list, keyNID, certNID, itt, macItt,
1846            keyType, NULL);
1847
1848    if (ca != NULL) {
1849        wc_FreeCertList(list, NULL);
1850    }
1851
1852    return pkcs12;
1853}
1854
1855
1856/* return WOLFSSL_SUCCESS on success, WOLFSSL_FAILURE on failure */
1857int wolfSSL_PKCS12_parse(WC_PKCS12* pkcs12, const char* psw,
1858          WOLFSSL_EVP_PKEY** pkey, WOLFSSL_X509** cert,
1859          WOLF_STACK_OF(WOLFSSL_X509)** ca)
1860{
1861    void* heap = NULL;
1862    int ret;
1863    byte* certData = NULL;
1864    word32 certDataSz;
1865    byte* pk = NULL;
1866    word32 pkSz;
1867    WC_DerCertList* certList = NULL;
1868    WC_DECLARE_VAR(DeCert, DecodedCert, 1, 0);
1869
1870    WOLFSSL_ENTER("wolfSSL_PKCS12_parse");
1871
1872    /* make sure we init return args */
1873    if (pkey) *pkey = NULL;
1874    if (cert) *cert = NULL;
1875    if (ca)   *ca = NULL;
1876
1877    if (pkcs12 == NULL || psw == NULL || pkey == NULL || cert == NULL) {
1878        WOLFSSL_MSG("Bad argument value");
1879        return WOLFSSL_FAILURE;
1880    }
1881
1882    heap  = wc_PKCS12_GetHeap(pkcs12);
1883
1884    if (ca == NULL) {
1885        ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz,
1886            NULL);
1887    }
1888    else {
1889        ret = wc_PKCS12_parse(pkcs12, psw, &pk, &pkSz, &certData, &certDataSz,
1890            &certList);
1891    }
1892    if (ret < 0) {
1893        WOLFSSL_LEAVE("wolfSSL_PKCS12_parse", ret);
1894        return WOLFSSL_FAILURE;
1895    }
1896
1897#ifdef WOLFSSL_SMALL_STACK
1898    DeCert = (DecodedCert *)XMALLOC(sizeof(*DeCert), heap,
1899                                    DYNAMIC_TYPE_DCERT);
1900    if (DeCert == NULL) {
1901        WOLFSSL_MSG("out of memory");
1902        return WOLFSSL_FAILURE;
1903    }
1904#endif
1905
1906    /* Decode cert and place in X509 stack struct */
1907    if (certList != NULL) {
1908        WC_DerCertList* current = certList;
1909
1910        *ca = (WOLF_STACK_OF(WOLFSSL_X509)*)XMALLOC(
1911            sizeof(WOLF_STACK_OF(WOLFSSL_X509)), heap, DYNAMIC_TYPE_X509);
1912        if (*ca == NULL) {
1913            XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
1914            XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
1915            /* Free up WC_DerCertList and move on */
1916            while (current != NULL) {
1917                WC_DerCertList* next = current->next;
1918
1919                XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
1920                XFREE(current, heap, DYNAMIC_TYPE_PKCS);
1921                current = next;
1922            }
1923            ret = WOLFSSL_FAILURE;
1924            goto out;
1925        }
1926        XMEMSET(*ca, 0, sizeof(WOLF_STACK_OF(WOLFSSL_X509)));
1927
1928        /* add list of DER certs as X509's to stack */
1929        while (current != NULL) {
1930            WC_DerCertList*  toFree = current;
1931            WOLFSSL_X509* x509;
1932
1933            x509 = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap,
1934                DYNAMIC_TYPE_X509);
1935            InitX509(x509, 1, heap);
1936            InitDecodedCert(DeCert, current->buffer, current->bufferSz, heap);
1937            if (ParseCertRelative(DeCert, CERT_TYPE, NO_VERIFY, NULL, NULL)
1938                                                                         != 0) {
1939                WOLFSSL_MSG("Issue with parsing certificate");
1940                FreeDecodedCert(DeCert);
1941                wolfSSL_X509_free(x509);
1942                x509 = NULL;
1943            }
1944            else {
1945                if (CopyDecodedToX509(x509, DeCert) != 0) {
1946                    WOLFSSL_MSG("Failed to copy decoded cert");
1947                    FreeDecodedCert(DeCert);
1948                    wolfSSL_X509_free(x509);
1949                    x509 = NULL;
1950                    wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
1951                    XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
1952                    XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
1953                    /* Free up WC_DerCertList */
1954                    while (current != NULL) {
1955                        WC_DerCertList* next = current->next;
1956
1957                        XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
1958                        XFREE(current, heap, DYNAMIC_TYPE_PKCS);
1959                        current = next;
1960                    }
1961                    ret = WOLFSSL_FAILURE;
1962                    goto out;
1963                }
1964                FreeDecodedCert(DeCert);
1965
1966                if (wolfSSL_sk_X509_push(*ca, x509) <= 0) {
1967                    WOLFSSL_MSG("Failed to push x509 onto stack");
1968                    wolfSSL_X509_free(x509);
1969                    x509 = NULL;
1970                    wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
1971                    XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
1972                    XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
1973
1974                    /* Free up WC_DerCertList */
1975                    while (current != NULL) {
1976                        WC_DerCertList* next = current->next;
1977
1978                        XFREE(current->buffer, heap, DYNAMIC_TYPE_PKCS);
1979                        XFREE(current, heap, DYNAMIC_TYPE_PKCS);
1980                        current = next;
1981                    }
1982                    ret = WOLFSSL_FAILURE;
1983                    goto out;
1984                }
1985            }
1986            current = current->next;
1987            XFREE(toFree->buffer, heap, DYNAMIC_TYPE_PKCS);
1988            XFREE(toFree, heap, DYNAMIC_TYPE_PKCS);
1989        }
1990    }
1991
1992
1993    /* Decode cert and place in X509 struct */
1994    if (certData != NULL) {
1995        *cert = (WOLFSSL_X509*)XMALLOC(sizeof(WOLFSSL_X509), heap,
1996            DYNAMIC_TYPE_X509);
1997        if (*cert == NULL) {
1998            XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
1999            if (ca != NULL) {
2000                wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
2001            }
2002            XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
2003            ret = WOLFSSL_FAILURE;
2004            goto out;
2005        }
2006        InitX509(*cert, 1, heap);
2007        InitDecodedCert(DeCert, certData, certDataSz, heap);
2008        if (ParseCertRelative(DeCert, CERT_TYPE, NO_VERIFY, NULL, NULL) != 0) {
2009            WOLFSSL_MSG("Issue with parsing certificate");
2010        }
2011        if (CopyDecodedToX509(*cert, DeCert) != 0) {
2012            WOLFSSL_MSG("Failed to copy decoded cert");
2013            FreeDecodedCert(DeCert);
2014            XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
2015            if (ca != NULL) {
2016                wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
2017            }
2018            wolfSSL_X509_free(*cert); *cert = NULL;
2019            XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
2020            ret = WOLFSSL_FAILURE;
2021            goto out;
2022        }
2023        FreeDecodedCert(DeCert);
2024        XFREE(certData, heap, DYNAMIC_TYPE_PKCS);
2025    }
2026
2027
2028    /* get key type */
2029    ret = BAD_STATE_E;
2030    if (pk != NULL) { /* decode key if present */
2031        *pkey = wolfSSL_EVP_PKEY_new_ex(heap);
2032        if (*pkey == NULL) {
2033            wolfSSL_X509_free(*cert); *cert = NULL;
2034            if (ca != NULL) {
2035                wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
2036            }
2037            XFREE(pk, heap, DYNAMIC_TYPE_PUBLIC_KEY);
2038            ret = WOLFSSL_FAILURE;
2039            goto out;
2040        }
2041
2042    #ifndef NO_RSA
2043        {
2044            const unsigned char* pt = pk;
2045            if (wolfSSL_d2i_PrivateKey(WC_EVP_PKEY_RSA, pkey, &pt, pkSz) !=
2046                    NULL) {
2047                ret = 0;
2048            }
2049        }
2050    #endif /* NO_RSA */
2051
2052    #ifdef HAVE_ECC
2053        if (ret != 0) { /* if is in fail state check if ECC key */
2054            const unsigned char* pt = pk;
2055            if (wolfSSL_d2i_PrivateKey(WC_EVP_PKEY_EC, pkey, &pt, pkSz) !=
2056                    NULL) {
2057                ret = 0;
2058            }
2059        }
2060    #endif /* HAVE_ECC */
2061        XFREE(pk, heap, DYNAMIC_TYPE_PKCS);
2062        if (ret != 0) { /* if is in fail state and no PKEY then fail */
2063            wolfSSL_X509_free(*cert); *cert = NULL;
2064            if (ca != NULL) {
2065                wolfSSL_sk_X509_pop_free(*ca, NULL); *ca = NULL;
2066            }
2067            wolfSSL_EVP_PKEY_free(*pkey); *pkey = NULL;
2068            WOLFSSL_MSG("Bad PKCS12 key format");
2069            ret = WOLFSSL_FAILURE;
2070            goto out;
2071        }
2072
2073        if (pkey != NULL && *pkey != NULL) {
2074            (*pkey)->save_type = 0;
2075        }
2076    }
2077
2078    (void)ret;
2079    (void)ca;
2080
2081    ret = WOLFSSL_SUCCESS;
2082
2083out:
2084
2085    WC_FREE_VAR_EX(DeCert, heap, DYNAMIC_TYPE_DCERT);
2086
2087    return ret;
2088}
2089
2090int wolfSSL_PKCS12_verify_mac(WC_PKCS12 *pkcs12, const char *psw,
2091        int pswLen)
2092{
2093    WOLFSSL_ENTER("wolfSSL_PKCS12_verify_mac");
2094
2095    if (!pkcs12) {
2096        return WOLFSSL_FAILURE;
2097    }
2098
2099    return wc_PKCS12_verify_ex(pkcs12, (const byte*)psw, (word32)pswLen) == 0 ?
2100            WOLFSSL_SUCCESS : WOLFSSL_FAILURE;
2101}
2102
2103#endif /* !NO_ASN && !NO_PWDBASED */
2104
2105#endif /* OPENSSL_EXTRA */
2106
2107#endif /* HAVE_PKCS12 */
2108/*******************************************************************************
2109 * END OF PKCS12 APIs
2110 ******************************************************************************/
2111
2112#endif /* !WOLFCRYPT_ONLY && !NO_CERTS */
2113
2114#endif /* !WOLFSSL_SSL_P7P12_INCLUDED */