Commit 204afd81 authored by Benjamin Kaduk's avatar Benjamin Kaduk Committed by Richard Levitte
Browse files

Add PEM_read_bio_ex 



The extended function includes a 'flags' argument to allow callers
to specify different requested behaviors.  In particular, callers can
request that temporary storage buffers are allocated from the secure heap,
which could be relevant when loading private key material.

Refactor PEM_read_bio to use BIO_mems instead of BUFs directly,
use some helper routines to reduce the overall function length, and make
some of the checks more reasonable.

Reviewed-by: default avatarRich Salz <rsalz@openssl.org>
Reviewed-by: default avatarRichard Levitte <levitte@openssl.org>
(Merged from https://github.com/openssl/openssl/pull/1700)
parent d396da33

crypto/pem/pem_err.c

+3 −0
Original line number Diff line number Diff line
@@ -33,6 +33,8 @@ static ERR_STRING_DATA PEM_str_functs[] = { 
    {ERR_FUNC(PEM_F_DO_PK8PKEY_FP), "do_pk8pkey_fp"},

    {ERR_FUNC(PEM_F_DO_PVK_BODY), "do_PVK_body"},

    {ERR_FUNC(PEM_F_DO_PVK_HEADER), "do_PVK_header"},

    {ERR_FUNC(PEM_F_GET_HEADER_AND_DATA), "get_header_and_data"},

    {ERR_FUNC(PEM_F_GET_NAME), "get_name"},

    {ERR_FUNC(PEM_F_I2B_PVK), "i2b_PVK"},

    {ERR_FUNC(PEM_F_I2B_PVK_BIO), "i2b_PVK_bio"},

    {ERR_FUNC(PEM_F_LOAD_IV), "load_iv"},
@@ -46,6 +48,7 @@ static ERR_STRING_DATA PEM_str_functs[] = { 
    {ERR_FUNC(PEM_F_PEM_READ), "PEM_read"},

    {ERR_FUNC(PEM_F_PEM_READ_BIO), "PEM_read_bio"},

    {ERR_FUNC(PEM_F_PEM_READ_BIO_DHPARAMS), "PEM_read_bio_DHparams"},

    {ERR_FUNC(PEM_F_PEM_READ_BIO_EX), "PEM_read_bio_ex"},

    {ERR_FUNC(PEM_F_PEM_READ_BIO_PARAMETERS), "PEM_read_bio_Parameters"},

    {ERR_FUNC(PEM_F_PEM_READ_BIO_PRIVATEKEY), "PEM_read_bio_PrivateKey"},

    {ERR_FUNC(PEM_F_PEM_READ_DHPARAMS), "PEM_read_DHparams"},

crypto/pem/pem_lib.c

+270 −141
Original line number Diff line number Diff line
@@ -228,6 +228,20 @@ static int check_pem(const char *nm, const char *name) 
    return 0;

}



static void pem_free(void *p, unsigned int flags)

{

    if (flags & PEM_FLAG_SECURE)

        OPENSSL_secure_free(p);

    else

        OPENSSL_free(p);

}



static void *pem_malloc(int num, unsigned int flags)

{

    return (flags & PEM_FLAG_SECURE) ? OPENSSL_secure_malloc(num)

                                     : OPENSSL_malloc(num);

}



int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,

                       const char *name, BIO *bp, pem_password_cb *cb,

                       void *u)
@@ -661,177 +675,292 @@ int PEM_read(FILE *fp, char **name, char **header, unsigned char **data, 
}

#endif



int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,

                 long *len)

/* Some helpers for PEM_read_bio_ex(). */



#define isb64(c) (isalnum(c) || (c) == '+' || (c) == '/' || (c) == '=')



static int sanitize_line(char *linebuf, int len, unsigned int flags)

{

    EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();

    int end = 0, i, k, bl = 0, hl = 0, nohead = 0;

    char buf[256];

    BUF_MEM *nameB;

    BUF_MEM *headerB;

    BUF_MEM *dataB, *tmpB;

    int i;



    if (ctx == NULL) {

        PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);

        return (0);

    if (flags & PEM_FLAG_EAY_COMPATIBLE) {

        /* Strip trailing whitespace */

        while ((len >= 0) && (linebuf[len] <= ' '))

            len--;

        /* Go back to whitespace before applying uniform line ending. */

        len++;

    } else if (flags & PEM_FLAG_ONLY_B64) {

        for (i = 0; i < len; ++i) {

            if (!isb64(linebuf[i]) || linebuf[i] == '\n' || linebuf[i] == '\r')

                break;

        }

        len = i;

    } else {

        /* EVP_DecodeBlock strips leading and trailing whitespace, so just strip

         * control characters in-place and let everything through. */

        for (i = 0; i < len; ++i) {

            if (linebuf[i] == '\n' || linebuf[i] == '\r')

                break;

            if (iscntrl(linebuf[i]))

                linebuf[i] = ' ';

        }

        len = i;

    }

    /* The caller allocated LINESIZE+1, so this is safe. */

    linebuf[len++] = '\n';

    linebuf[len] = '\0';

    return len;

}



#define LINESIZE 255

/* Note trailing spaces for begin and end. */

static const char beginstr[] = "-----BEGIN ";

static const char endstr[] = "-----END ";

static const char tailstr[] = "-----\n";

#define BEGINLEN (sizeof(beginstr) - 1)

#define ENDLEN (sizeof(endstr) - 1)

#define TAILLEN (sizeof(tailstr) - 1)

static int get_name(BIO *bp, char **name, unsigned int flags)

{

    char *linebuf;

    int ret = 0;

    size_t len;



    nameB = BUF_MEM_new();

    headerB = BUF_MEM_new();

    dataB = BUF_MEM_new();

    if ((nameB == NULL) || (headerB == NULL) || (dataB == NULL)) {

        goto err;

    /*

     * Need to hold trailing NUL (accounted for by BIO_gets() and the newline

     * that will be added by sanitize_line() (the extra '1').

     */

    linebuf = pem_malloc(LINESIZE + 1, flags);

    if (linebuf == NULL) {

        PEMerr(PEM_F_GET_NAME, ERR_R_MALLOC_FAILURE);

        return 0;

    }



    buf[254] = '\0';

    for (;;) {

        i = BIO_gets(bp, buf, 254);

    do {

        len = BIO_gets(bp, linebuf, LINESIZE);



        if (i <= 0) {

            PEMerr(PEM_F_PEM_READ_BIO, PEM_R_NO_START_LINE);

        if (len <= 0) {

            PEMerr(PEM_F_GET_NAME, PEM_R_NO_START_LINE);

            goto err;

        }



        while ((i >= 0) && (buf[i] <= ' '))

            i--;

        buf[++i] = '\n';

        buf[++i] = '\0';

        /* Strip trailing garbage and standardize ending. */

        len = sanitize_line(linebuf, len, flags & ~PEM_FLAG_ONLY_B64);



        if (strncmp(buf, "-----BEGIN ", 11) == 0) {

            i = strlen(&(buf[11]));



            if (strncmp(&(buf[11 + i - 6]), "-----\n", 6) != 0)

                continue;

            if (!BUF_MEM_grow(nameB, i + 9)) {

                PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);

        /* Allow leading empty or non-matching lines. */

    } while (strncmp(linebuf, beginstr, BEGINLEN) != 0

             || len < TAILLEN

             || strncmp(linebuf + len - TAILLEN, tailstr, TAILLEN) != 0);

    linebuf[len - TAILLEN] = '\0';

    len = len - BEGINLEN - TAILLEN + 1;

    *name = pem_malloc(len, flags);

    if (*name == NULL) {

        PEMerr(PEM_F_GET_NAME, ERR_R_MALLOC_FAILURE);

        goto err;

    }

            memcpy(nameB->data, &(buf[11]), i - 6);

            nameB->data[i - 6] = '\0';

            break;

    memcpy(*name, linebuf + BEGINLEN, len);

    ret = 1;



err:

    pem_free(linebuf, flags);

    return ret;

}



/* Keep track of how much of a header we've seen. */

enum header_status {

    MAYBE_HEADER,

    IN_HEADER,

    POST_HEADER

};



/**

 * Extract the optional PEM header, with details on the type of content and

 * any encryption used on the contents, and the bulk of the data from the bio.

 * The end of the header is marked by a blank line; if the end-of-input marker

 * is reached prior to a blank line, there is no header.

 *

 * The header and data arguments are BIO** since we may have to swap them

 * if there is no header, for efficiency.

 *

 * We need the name of the PEM-encoded type to verify the end string.

 */

static int get_header_and_data(BIO *bp, BIO **header, BIO **data, char *name,

                               unsigned int flags)

{

    BIO *tmp = *header;

    char *linebuf, *p;

    int len, line, ret = 0, end = 0;

    /* 0 if not seen (yet), 1 if reading header, 2 if finished header */

    enum header_status got_header = MAYBE_HEADER;

    unsigned int flags_mask;

    size_t namelen;



    /* Need to hold trailing NUL (accounted for by BIO_gets() and the newline

     * that will be added by sanitize_line() (the extra '1'). */

    linebuf = pem_malloc(LINESIZE + 1, flags);

    if (linebuf == NULL) {

        PEMerr(PEM_F_GET_HEADER_AND_DATA, ERR_R_MALLOC_FAILURE);

        return 0;

    }

    hl = 0;

    if (!BUF_MEM_grow(headerB, 256)) {

        PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);



    for (line = 0; ; line++) {

        flags_mask = ~0u;

        len = BIO_gets(bp, linebuf, LINESIZE);

        if (len <= 0) {

            PEMerr(PEM_F_GET_HEADER_AND_DATA, PEM_R_SHORT_HEADER);

            goto err;

        }

    headerB->data[0] = '\0';

    for (;;) {

        i = BIO_gets(bp, buf, 254);

        if (i <= 0)

            break;



        while ((i >= 0) && (buf[i] <= ' '))

            i--;

        buf[++i] = '\n';

        buf[++i] = '\0';

        if (got_header == MAYBE_HEADER) {

            if (memchr(linebuf, ':', len) != NULL)

                got_header = IN_HEADER;

        }

        if (!strncmp(linebuf, endstr, ENDLEN) || got_header == IN_HEADER)

            flags_mask &= ~PEM_FLAG_ONLY_B64;

        len = sanitize_line(linebuf, len, flags & flags_mask);



        if (buf[0] == '\n')

            break;

        if (!BUF_MEM_grow(headerB, hl + i + 9)) {

            PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);

        /* Check for end of header. */

        if (linebuf[0] == '\n') {

            if (got_header == POST_HEADER) {

                /* Another blank line is an error. */

                PEMerr(PEM_F_GET_HEADER_AND_DATA, PEM_R_BAD_END_LINE);

                goto err;

            }

        if (strncmp(buf, "-----END ", 9) == 0) {

            nohead = 1;

            break;

        }

        memcpy(&(headerB->data[hl]), buf, i);

        headerB->data[hl + i] = '\0';

        hl += i;

            got_header = POST_HEADER;

            tmp = *data;

            continue;

        }



    bl = 0;

    if (!BUF_MEM_grow(dataB, 1024)) {

        PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);

        /* Check for end of stream (which means there is no header). */

        if (strncmp(linebuf, endstr, ENDLEN) == 0) {

            p = linebuf + ENDLEN;

            namelen = strlen(name);

            if (strncmp(p, name, namelen) != 0 ||

                strncmp(p + namelen, tailstr, TAILLEN) != 0) {

                PEMerr(PEM_F_GET_HEADER_AND_DATA, PEM_R_BAD_END_LINE);

                goto err;

            }

    dataB->data[0] = '\0';

    if (!nohead) {

        for (;;) {

            i = BIO_gets(bp, buf, 254);

            if (i <= 0)

                break;



            while ((i >= 0) && (buf[i] <= ' '))

                i--;

            buf[++i] = '\n';

            buf[++i] = '\0';



            if (i != 65)

                end = 1;

            if (strncmp(buf, "-----END ", 9) == 0)

                break;

            if (i > 65)

            if (got_header == MAYBE_HEADER) {

                *header = *data;

                *data = tmp;

            }

            break;

            if (!BUF_MEM_grow_clean(dataB, i + bl + 9)) {

                PEMerr(PEM_F_PEM_READ_BIO, ERR_R_MALLOC_FAILURE);

        } else if (end) {

            /* Malformed input; short line not at end of data. */

            PEMerr(PEM_F_GET_HEADER_AND_DATA, PEM_R_BAD_END_LINE);

            goto err;

        }

            memcpy(&(dataB->data[bl]), buf, i);

            dataB->data[bl + i] = '\0';

            bl += i;

            if (end) {

                buf[0] = '\0';

                i = BIO_gets(bp, buf, 254);

                if (i <= 0)

                    break;

        /*

         * Else, a line of text -- could be header or data; we don't

         * know yet.  Just pass it through.

         */

        BIO_puts(tmp, linebuf);

        /*

         * Only encrypted files need the line length check applied.

         */

        if (got_header == POST_HEADER) {

            /* 65 includes the trailing newline */

            if (len > 65)

                goto err;

            if (len < 65)

                end = 1;

        }

    }



                while ((i >= 0) && (buf[i] <= ' '))

                    i--;

                buf[++i] = '\n';

                buf[++i] = '\0';

    ret = 1;

err:

    pem_free(linebuf, flags);

    return ret;

}



                break;

/**

 * Read in PEM-formatted data from the given BIO.

 *

 * By nature of the PEM format, all content must be printable ASCII (except

 * for line endings).  Other characters, or lines that are longer than 80

 * characters, are malformed input and will be rejected.

 */

int PEM_read_bio_ex(BIO *bp, char **name_out, char **header,

                    unsigned char **data, long *len_out, unsigned int flags)

{

    EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();

    const BIO_METHOD *bmeth;

    BIO *headerB = NULL, *dataB = NULL;

    char *name = NULL;

    int len, taillen, headerlen, ret = 0;

    BUF_MEM * buf_mem;



    if (ctx == NULL) {

        PEMerr(PEM_F_PEM_READ_BIO_EX, ERR_R_MALLOC_FAILURE);

        return 0;

    }



    *len_out = 0;

    *name_out = *header = NULL;

    *data = NULL;

    if ((flags & PEM_FLAG_EAY_COMPATIBLE) && (flags & PEM_FLAG_ONLY_B64)) {

        /* These two are mutually incompatible; bail out. */

        PEMerr(PEM_F_PEM_READ_BIO_EX, ERR_R_PASSED_INVALID_ARGUMENT);

        goto end;

    }

    } else {

        tmpB = headerB;

        headerB = dataB;

        dataB = tmpB;

        bl = hl;

    }

    i = strlen(nameB->data);

    if ((strncmp(buf, "-----END ", 9) != 0) ||

        (strncmp(nameB->data, &(buf[9]), i) != 0) ||

        (strncmp(&(buf[9 + i]), "-----\n", 6) != 0)) {

        PEMerr(PEM_F_PEM_READ_BIO, PEM_R_BAD_END_LINE);

        goto err;

    bmeth = (flags & PEM_FLAG_SECURE) ? BIO_s_secmem() : BIO_s_mem();



    headerB = BIO_new(bmeth);

    dataB = BIO_new(bmeth);

    if (headerB == NULL || dataB == NULL) {

        PEMerr(PEM_F_PEM_READ_BIO_EX, ERR_R_MALLOC_FAILURE);

        goto end;

    }



    if (!get_name(bp, &name, flags))

        goto end;

    if (!get_header_and_data(bp, &headerB, &dataB, name, flags))

        goto end;



    EVP_DecodeInit(ctx);

    i = EVP_DecodeUpdate(ctx,

                         (unsigned char *)dataB->data, &bl,

                         (unsigned char *)dataB->data, bl);

    if (i < 0) {

        PEMerr(PEM_F_PEM_READ_BIO, PEM_R_BAD_BASE64_DECODE);

        goto err;

    }

    i = EVP_DecodeFinal(ctx, (unsigned char *)&(dataB->data[bl]), &k);

    if (i < 0) {

        PEMerr(PEM_F_PEM_READ_BIO, PEM_R_BAD_BASE64_DECODE);

        goto err;

    }

    bl += k;

    BIO_get_mem_ptr(dataB, &buf_mem);

    len = buf_mem->length;

    if (EVP_DecodeUpdate(ctx, (unsigned char*)buf_mem->data, &len,

                         (unsigned char*)buf_mem->data, len) < 0

            || EVP_DecodeFinal(ctx, (unsigned char*)&(buf_mem->data[len]),

                               &taillen) < 0) {

        PEMerr(PEM_F_PEM_READ_BIO_EX, PEM_R_BAD_BASE64_DECODE);

        goto end;

    }

    len += taillen;

    buf_mem->length = len;



    /* There was no data in the PEM file; avoid malloc(0). */

    if (len == 0)

        goto end;

    headerlen = BIO_get_mem_data(headerB, NULL);

    *header = pem_malloc(headerlen + 1, flags);

    *data = pem_malloc(len, flags);

    if (*header == NULL || *data == NULL) {

        pem_free(*header, flags);

        pem_free(*data, flags);

        goto end;

    }

    BIO_read(headerB, *header, headerlen);

    (*header)[headerlen] = '\0';

    BIO_read(dataB, *data, len);

    *len_out = len;

    *name_out = name;

    name = NULL;

    ret = 1;



    if (bl == 0)

        goto err;

    *name = nameB->data;

    *header = headerB->data;

    *data = (unsigned char *)dataB->data;

    *len = bl;

    OPENSSL_free(nameB);

    OPENSSL_free(headerB);

    OPENSSL_free(dataB);

    EVP_ENCODE_CTX_free(ctx);

    return (1);

 err:

    BUF_MEM_free(nameB);

    BUF_MEM_free(headerB);

    BUF_MEM_free(dataB);

end:

    EVP_ENCODE_CTX_free(ctx);

    return (0);

    pem_free(name, flags);

    BIO_free(headerB);

    BIO_free(dataB);

    return ret;

}



int PEM_read_bio(BIO *bp, char **name, char **header, unsigned char **data,

                 long *len)

{

    return PEM_read_bio_ex(bp, name, header, data, len, PEM_FLAG_EAY_COMPATIBLE);

}



/*

doc/man3/PEM_read_bio_ex.pod

0 → 100644
+70 −0
Original line number Diff line number Diff line 
=pod



=head1 NAME



PEM_read_bio_ex, PEM_FLAG_SECURE, PEM_FLAG_EAY_COMPATIBLE,

PEM_FLAG_ONLY_B64 - read PEM format files with custom processing



=head1 SYNOPSIS



 #include <openssl/pem.h>



 #define PEM_FLAG_SECURE             0x1

 #define PEM_FLAG_EAY_COMPATIBLE     0x2

 #define PEM_FLAG_ONLY_B64           0x4

 int PEM_read_bio_ex(BIO *in, char **name, char **header,

                     unsigned char **data, long *len, unsigned int flags);



=head1 DESCRIPTION



PEM_read_bio_ex() reads in PEM formatted data from an input BIO, outputting

the name of the type of contained data, the header information regarding

the possibly encrypted data, and the binary data payload (after base64 decoding).

It should generally only be used to implement PEM_read_bio_-family functions

for specific data types or other usage, but is exposed to allow greater flexibility

over how processing is performed, if needed.



If PEM_FLAG_SECURE is set, the intermediate buffers used to read in lines of

input are allocated from the secure heap.



If PEM_FLAG_EAY_COMPATIBLE is set, a simple algorithm is used to remove whitespace

and control characters from the end of each line, so as to be compatible with

the historical behavior of PEM_read_bio().



If PEM_FLAG_ONLY_B64 is set, all characters are required to be valid base64

characters (or newlines); non-base64 characters are treated as end of input.



If neither PEM_FLAG_EAY_COMPATIBLE or PEM_FLAG_ONLY_B64 is set, control characters

are ignored.



If both PEM_FLAG_EAY_COMPATIBLE and PEM_FLAG_ONLY_B64 are set, an error is returned;

these options are not compatible with each other.



=head1 NOTES



The caller must release the storage allocated for *name, *header, and *data.

If PEM_FLAG_SECURE was set, use OPENSSL_secure_free(); otherwise,

OPENSSL_free() is used.



=head1 RETURN VALUES



PEM_read_bio_ex() returns 1 for success or 0 for failure.



=head1 SEE ALSO



L<PEM(3)>



=head1 HISTORY



PEM_read_bio_ex() was added in OpenSSL 1.1.1.



=head1 COPYRIGHT



Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.



Licensed under the OpenSSL license (the "License").  You may not use

this file except in compliance with the License.  You can obtain a copy

in the file LICENSE in the source distribution or at

L<https://www.openssl.org/source/license.html>.



=cut

include/openssl/pem.h

+8 −0
Original line number Diff line number Diff line
@@ -236,6 +236,11 @@ int PEM_do_header(EVP_CIPHER_INFO *cipher, unsigned char *data, long *len, 


int PEM_read_bio(BIO *bp, char **name, char **header,

                 unsigned char **data, long *len);

#   define PEM_FLAG_SECURE             0x1

#   define PEM_FLAG_EAY_COMPATIBLE     0x2

#   define PEM_FLAG_ONLY_B64           0x4

int PEM_read_bio_ex(BIO *bp, char **name, char **header,

                    unsigned char **data, long *len, unsigned int flags);

int PEM_write_bio(BIO *bp, const char *name, const char *hdr,

                  const unsigned char *data, long len);

int PEM_bytes_read_bio(unsigned char **pdata, long *plen, char **pnm,
@@ -388,6 +393,8 @@ int ERR_load_PEM_strings(void); 
# define PEM_F_DO_PK8PKEY_FP                              125

# define PEM_F_DO_PVK_BODY                                135

# define PEM_F_DO_PVK_HEADER                              136

# define PEM_F_GET_HEADER_AND_DATA                        143

# define PEM_F_GET_NAME                                   144

# define PEM_F_I2B_PVK                                    137

# define PEM_F_I2B_PVK_BIO                                138

# define PEM_F_LOAD_IV                                    101
@@ -401,6 +408,7 @@ int ERR_load_PEM_strings(void); 
# define PEM_F_PEM_READ                                   108

# define PEM_F_PEM_READ_BIO                               109

# define PEM_F_PEM_READ_BIO_DHPARAMS                      141

# define PEM_F_PEM_READ_BIO_EX                            145

# define PEM_F_PEM_READ_BIO_PARAMETERS                    140

# define PEM_F_PEM_READ_BIO_PRIVATEKEY                    123

# define PEM_F_PEM_READ_DHPARAMS                          142

util/libcrypto.num

+1 −0
Original line number Diff line number Diff line
@@ -4288,3 +4288,4 @@ TS_CONF_set_ess_cert_id_digest 4230 1_1_1 EXIST::FUNCTION:TS 
ESS_SIGNING_CERT_V2_free                4231	1_1_1	EXIST::FUNCTION:TS

ESS_SIGNING_CERT_V2_dup                 4232	1_1_1	EXIST::FUNCTION:TS

ESS_CERT_ID_V2_new                      4233	1_1_1	EXIST::FUNCTION:TS

PEM_read_bio_ex                         4234	1_1_1	EXIST::FUNCTION: