[thirdparty/openssl.git] / ssl / ssl_cert_comp.c

/*
 * Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (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
 * https://www.openssl.org/source/license.html
 */

#include <stdio.h>
#include "ssl_local.h"
#include "internal/e_os.h"
#include "internal/refcount.h"

size_t ossl_calculate_comp_expansion(int alg, size_t length)
{
    size_t ret;
    /*
     * Uncompressibility expansion:
     * ZLIB: N + 11 + 5 * (N >> 14)
     * Brotli: per RFC7932: N + 5 + 3 * (N >> 16)
     * ZSTD: N + 4 + 14 + 3 * (N >> 17) + 4
     */
    
    switch (alg) {
    case TLSEXT_comp_cert_zlib:
        ret = length + 11 + 5 * (length >> 14);
        break;
    case TLSEXT_comp_cert_brotli:
        ret = length + 5 + 3 * (length >> 16);
        break;
    case TLSEXT_comp_cert_zstd:
        ret = length + 22 + 3 * (length >> 17);
        break;
    default:
        return 0;
    }
    /* Check for overflow */
    if (ret < length)
        return 0;
    return ret;
}

int ossl_comp_has_alg(int a)
{
#ifndef OPENSSL_NO_COMP_ALG
    /* 0 means "any" algorithm */
    if ((a == 0 || a == TLSEXT_comp_cert_brotli) && BIO_f_brotli() != NULL)
        return 1;
    if ((a == 0 || a == TLSEXT_comp_cert_zstd) && BIO_f_zstd() != NULL)
        return 1;
    if ((a == 0 || a == TLSEXT_comp_cert_zlib) && BIO_f_zlib() != NULL)
        return 1;
#endif
    return 0;
}

/* New operation Helper routine */
#ifndef OPENSSL_NO_COMP_ALG
static OSSL_COMP_CERT *OSSL_COMP_CERT_new(unsigned char *data, size_t len, size_t orig_len, int alg)
{
    OSSL_COMP_CERT *ret = NULL;

    if (!ossl_comp_has_alg(alg)
            || data == NULL
            || (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL
            || !CRYPTO_NEW_REF(&ret->references, 1))
        goto err;

    ret->data = data;
    ret->len = len;
    ret->orig_len = orig_len;
    ret->alg = alg;
    return ret;
 err:
    ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
    OPENSSL_free(data);
    OPENSSL_free(ret);
    return NULL;
}

__owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_compressed_data(unsigned char *data, size_t len,
                                                                  size_t orig_len, int alg)
{
    return OSSL_COMP_CERT_new(OPENSSL_memdup(data, len), len, orig_len, alg);
}

__owur static OSSL_COMP_CERT *OSSL_COMP_CERT_from_uncompressed_data(unsigned char *data, size_t len,
                                                                    int alg)
{
    OSSL_COMP_CERT *ret = NULL;
    size_t max_length;
    int comp_length;
    COMP_METHOD *method;
    unsigned char *comp_data = NULL;
    COMP_CTX *comp_ctx = NULL;

    switch (alg) {
    case TLSEXT_comp_cert_brotli:
        method = COMP_brotli_oneshot();
        break;
    case TLSEXT_comp_cert_zlib:
        method = COMP_zlib_oneshot();
        break;
    case TLSEXT_comp_cert_zstd:
        method = COMP_zstd_oneshot();
        break;
    default:
        goto err;
    }

    if ((max_length = ossl_calculate_comp_expansion(alg, len)) == 0
          || method == NULL
          || (comp_ctx = COMP_CTX_new(method)) == NULL
          || (comp_data = OPENSSL_zalloc(max_length)) == NULL)
        goto err;

    comp_length = COMP_compress_block(comp_ctx, comp_data, max_length, data, len);
    if (comp_length <= 0)
        goto err;

    ret = OSSL_COMP_CERT_new(comp_data, comp_length, len, alg);
    comp_data = NULL;

 err:
    OPENSSL_free(comp_data);
    COMP_CTX_free(comp_ctx);
    return ret;
}

void OSSL_COMP_CERT_free(OSSL_COMP_CERT *cc)
{
    int i;

    if (cc == NULL)
        return;

    CRYPTO_DOWN_REF(&cc->references, &i);
    REF_PRINT_COUNT("OSSL_COMP_CERT", cc);
    if (i > 0)
        return;
    REF_ASSERT_ISNT(i < 0);

    OPENSSL_free(cc->data);
    CRYPTO_FREE_REF(&cc->references);
    OPENSSL_free(cc);
}
int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT *cc)
{
    int i;

    if (CRYPTO_UP_REF(&cc->references, &i) <= 0)
        return 0;

    REF_PRINT_COUNT("OSSL_COMP_CERT", cc);
    REF_ASSERT_ISNT(i < 2);
    return ((i > 1) ? 1 : 0);
}

static int ssl_set_cert_comp_pref(int *prefs, int *algs, size_t len)
{
    size_t j = 0;
    size_t i;
    int found = 0;
    int already_set[TLSEXT_comp_cert_limit];
    int tmp_prefs[TLSEXT_comp_cert_limit];

    /* Note that |len| is the number of |algs| elements */
    /* clear all algorithms */
    if (len == 0 || algs == NULL) {
        memset(prefs, 0, sizeof(tmp_prefs));
        return 1;
    }

    /* This will 0-terminate the array */
    memset(tmp_prefs, 0, sizeof(tmp_prefs));
    memset(already_set, 0, sizeof(already_set));
    /* Include only those algorithms we support, ignoring duplicates and unknowns */
    for (i = 0; i < len; i++) {
        if (algs[i] != 0 && ossl_comp_has_alg(algs[i])) {
            /* Check for duplicate */
            if (already_set[algs[i]])
                return 0;
            tmp_prefs[j++] = algs[i];
            already_set[algs[i]] = 1;
            found = 1;
        }
    }
    if (found)
        memcpy(prefs, tmp_prefs, sizeof(tmp_prefs));
    return found;
}

static size_t ssl_get_cert_to_compress(SSL *ssl, CERT_PKEY *cpk, unsigned char **data)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
    WPACKET tmppkt;
    BUF_MEM buf = { 0 };
    size_t ret = 0;

    if (sc == NULL
            || cpk == NULL
            || !sc->server
            || !SSL_in_before(ssl))
        return 0;

    /* Use the |tmppkt| for the to-be-compressed data */
    if (!WPACKET_init(&tmppkt, &buf))
        goto out;

    /* no context present, add 0-length context */
    if (!WPACKET_put_bytes_u8(&tmppkt, 0))
        goto out;

    /*
     * ssl3_output_cert_chain() may generate an SSLfatal() error,
     * for this case, we want to ignore it, argument for_comp = 1
     */
    if (!ssl3_output_cert_chain(sc, &tmppkt, cpk, 1))
        goto out;
    WPACKET_get_total_written(&tmppkt, &ret);

 out:
    WPACKET_cleanup(&tmppkt);
    if (ret != 0 && data != NULL)
        *data = (unsigned char *)buf.data;
    else
        OPENSSL_free(buf.data);
    return ret;
}

static int ssl_compress_one_cert(SSL *ssl, CERT_PKEY *cpk, int alg)
{
    unsigned char *cert_data = NULL;
    OSSL_COMP_CERT *comp_cert = NULL;
    size_t length;

    if (cpk == NULL
            || alg == TLSEXT_comp_cert_none
            || !ossl_comp_has_alg(alg))
        return 0;

    if ((length = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
        return 0;
    comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, length, alg);
    OPENSSL_free(cert_data);
    if (comp_cert == NULL)
        return 0;

    OSSL_COMP_CERT_free(cpk->comp_cert[alg]);
    cpk->comp_cert[alg] = comp_cert;
    return 1;
}

/* alg_in can be 0, meaning any/all algorithms */
static int ssl_compress_certs(SSL *ssl, CERT_PKEY *cpks, int alg_in)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
    int i;
    int j;
    int alg;
    int count = 0;

    if (sc == NULL
            || cpks == NULL
            || !ossl_comp_has_alg(alg_in))
        return 0;

    /* Look through the preferences to see what we have */
    for (i = 0; i < TLSEXT_comp_cert_limit; i++) {
        /*
         * alg = 0 means compress for everything, but only for algorithms enabled
         * alg != 0 means compress for that algorithm if enabled
         */
        alg = sc->cert_comp_prefs[i];
        if ((alg_in == 0 && alg != TLSEXT_comp_cert_none)
                || (alg_in != 0 && alg == alg_in)) {

            for (j = 0; j < SSL_PKEY_NUM; j++) {
                /* No cert, move on */
                if (cpks[j].x509 == NULL)
                    continue;

                if (!ssl_compress_one_cert(ssl, &cpks[j], alg))
                    return 0;

                /* if the cert expanded, set the value in the CERT_PKEY to NULL */
                if (cpks[j].comp_cert[alg]->len >= cpks[j].comp_cert[alg]->orig_len) {
                    OSSL_COMP_CERT_free(cpks[j].comp_cert[alg]);
                    cpks[j].comp_cert[alg] = NULL;
                } else {
                    count++;
                }
            }
        }
    }
    return (count > 0);
}

static size_t ssl_get_compressed_cert(SSL *ssl, CERT_PKEY *cpk, int alg, unsigned char **data,
                                      size_t *orig_len)
{
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
    size_t cert_len = 0;
    size_t comp_len = 0;
    unsigned char *cert_data = NULL;
    OSSL_COMP_CERT *comp_cert = NULL;

    if (sc == NULL
            || cpk == NULL
            || data == NULL
            || orig_len == NULL
            || !sc->server
            || !SSL_in_before(ssl)
            || !ossl_comp_has_alg(alg))
        return 0;

    if ((cert_len = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
        goto err;

    comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, cert_len, alg);
    OPENSSL_free(cert_data);
    if (comp_cert == NULL)
        goto err;

    comp_len = comp_cert->len;
    *orig_len = comp_cert->orig_len;
    *data = comp_cert->data;
    comp_cert->data = NULL;
 err:
    OSSL_COMP_CERT_free(comp_cert);
    return comp_len;
}

static int ossl_set1_compressed_cert(CERT *cert, int algorithm,
                                     unsigned char *comp_data, size_t comp_length,
                                     size_t orig_length)
{
    OSSL_COMP_CERT *comp_cert;

    /* No explicit cert set */
    if (cert == NULL || cert->key == NULL)
        return 0;

    comp_cert = OSSL_COMP_CERT_from_compressed_data(comp_data, comp_length,
                                                    orig_length, algorithm);
    if (comp_cert == NULL)
        return 0;

    OSSL_COMP_CERT_free(cert->key->comp_cert[algorithm]);
    cert->key->comp_cert[algorithm] = comp_cert;

    return 1;
}
#endif

/*-
 * Public API
 */
int SSL_CTX_set1_cert_comp_preference(SSL_CTX *ctx, int *algs, size_t len)
{
#ifndef OPENSSL_NO_COMP_ALG
    return ssl_set_cert_comp_pref(ctx->cert_comp_prefs, algs, len);
#else
    return 0;
#endif
}

int SSL_set1_cert_comp_preference(SSL *ssl, int *algs, size_t len)
{
#ifndef OPENSSL_NO_COMP_ALG
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);

    if (sc == NULL)
        return 0;
    return ssl_set_cert_comp_pref(sc->cert_comp_prefs, algs, len);
#else
    return 0;
#endif
}

int SSL_compress_certs(SSL *ssl, int alg)
{
#ifndef OPENSSL_NO_COMP_ALG
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);

    if (sc == NULL || sc->cert == NULL)
        return 0;

    return ssl_compress_certs(ssl, sc->cert->pkeys, alg);
#endif
    return 0;
}

int SSL_CTX_compress_certs(SSL_CTX *ctx, int alg)
{
    int ret = 0;
#ifndef OPENSSL_NO_COMP_ALG
    SSL *new = SSL_new(ctx);

    if (new == NULL)
        return 0;

    ret = ssl_compress_certs(new, ctx->cert->pkeys, alg);
    SSL_free(new);
#endif
    return ret;
}

size_t SSL_get1_compressed_cert(SSL *ssl, int alg, unsigned char **data, size_t *orig_len)
{
#ifndef OPENSSL_NO_COMP_ALG
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
    CERT_PKEY *cpk = NULL;

    if (sc->cert != NULL)
        cpk = sc->cert->key;
    else
        cpk = ssl->ctx->cert->key;

    return ssl_get_compressed_cert(ssl, cpk, alg, data, orig_len);
#else
    return 0;
#endif
}

size_t SSL_CTX_get1_compressed_cert(SSL_CTX *ctx, int alg, unsigned char **data, size_t *orig_len)
{
#ifndef OPENSSL_NO_COMP_ALG
    size_t ret;
    SSL *new = SSL_new(ctx);

    ret = ssl_get_compressed_cert(new, ctx->cert->key, alg, data, orig_len);
    SSL_free(new);
    return ret;
#else
        return 0;
#endif
}

int SSL_CTX_set1_compressed_cert(SSL_CTX *ctx, int algorithm, unsigned char *comp_data,
                                 size_t comp_length, size_t orig_length)
{
#ifndef OPENSSL_NO_COMP_ALG
    return ossl_set1_compressed_cert(ctx->cert, algorithm, comp_data, comp_length, orig_length);
#else
    return 0;
#endif
}

int SSL_set1_compressed_cert(SSL *ssl, int algorithm, unsigned char *comp_data,
                             size_t comp_length, size_t orig_length)
{
#ifndef OPENSSL_NO_COMP_ALG
    SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);

    /* Cannot set a pre-compressed certificate on a client */
    if (sc == NULL || !sc->server)
        return 0;

    return ossl_set1_compressed_cert(sc->cert, algorithm, comp_data, comp_length, orig_length);
#else
    return 0;
#endif
}
Commit	Line	Data
b67cb09f	1	/*
da1c088f	2	* Copyright 2022-2023 The OpenSSL Project Authors. All Rights Reserved.
b67cb09f TS	3	*
	4	* Licensed under the Apache License 2.0 (the "License"). You may not use
	5	* this file except in compliance with the License. You can obtain a copy
	6	* in the file LICENSE in the source distribution or at
	7	* https://www.openssl.org/source/license.html
	8	*/
	9
	10	#include <stdio.h>
	11	#include "ssl_local.h"
	12	#include "internal/e_os.h"
	13	#include "internal/refcount.h"
	14
	15	size_t ossl_calculate_comp_expansion(int alg, size_t length)
	16	{
	17	size_t ret;
	18	/*
	19	* Uncompressibility expansion:
	20	* ZLIB: N + 11 + 5 * (N >> 14)
	21	* Brotli: per RFC7932: N + 5 + 3 * (N >> 16)
	22	* ZSTD: N + 4 + 14 + 3 * (N >> 17) + 4
	23	*/
	24
	25	switch (alg) {
	26	case TLSEXT_comp_cert_zlib:
	27	ret = length + 11 + 5 * (length >> 14);
	28	break;
	29	case TLSEXT_comp_cert_brotli:
	30	ret = length + 5 + 3 * (length >> 16);
	31	break;
	32	case TLSEXT_comp_cert_zstd:
	33	ret = length + 22 + 3 * (length >> 17);
	34	break;
	35	default:
	36	return 0;
	37	}
	38	/* Check for overflow */
	39	if (ret < length)
	40	return 0;
	41	return ret;
	42	}
	43
	44	int ossl_comp_has_alg(int a)
	45	{
	46	#ifndef OPENSSL_NO_COMP_ALG
	47	/* 0 means "any" algorithm */
	48	if ((a == 0 \|\| a == TLSEXT_comp_cert_brotli) && BIO_f_brotli() != NULL)
	49	return 1;
	50	if ((a == 0 \|\| a == TLSEXT_comp_cert_zstd) && BIO_f_zstd() != NULL)
	51	return 1;
	52	if ((a == 0 \|\| a == TLSEXT_comp_cert_zlib) && BIO_f_zlib() != NULL)
	53	return 1;
	54	#endif
	55	return 0;
	56	}
	57
	58	/* New operation Helper routine */
	59	#ifndef OPENSSL_NO_COMP_ALG
	60	static OSSL_COMP_CERT OSSL_COMP_CERT_new(unsigned char data, size_t len, size_t orig_len, int alg)
	61	{
	62	OSSL_COMP_CERT *ret = NULL;
	63
	64	if (!ossl_comp_has_alg(alg)
	65	\|\| data == NULL
	66	\|\| (ret = OPENSSL_zalloc(sizeof(*ret))) == NULL
43a07d6d	67	\|\| !CRYPTO_NEW_REF(&ret->references, 1))
b67cb09f TS	68	goto err;
b67cb09f TS	69
b67cb09f TS	70	ret->data = data;
	71	ret->len = len;
	72	ret->orig_len = orig_len;
	73	ret->alg = alg;
	74	return ret;
	75	err:
	76	ERR_raise(ERR_LIB_SSL, ERR_R_MALLOC_FAILURE);
	77	OPENSSL_free(data);
	78	OPENSSL_free(ret);
	79	return NULL;
	80	}
	81
	82	__owur static OSSL_COMP_CERT OSSL_COMP_CERT_from_compressed_data(unsigned char data, size_t len,
	83	size_t orig_len, int alg)
	84	{
	85	return OSSL_COMP_CERT_new(OPENSSL_memdup(data, len), len, orig_len, alg);
	86	}
	87
	88	__owur static OSSL_COMP_CERT OSSL_COMP_CERT_from_uncompressed_data(unsigned char data, size_t len,
	89	int alg)
	90	{
	91	OSSL_COMP_CERT *ret = NULL;
	92	size_t max_length;
	93	int comp_length;
	94	COMP_METHOD *method;
	95	unsigned char *comp_data = NULL;
	96	COMP_CTX *comp_ctx = NULL;
	97
	98	switch (alg) {
	99	case TLSEXT_comp_cert_brotli:
	100	method = COMP_brotli_oneshot();
	101	break;
	102	case TLSEXT_comp_cert_zlib:
3840271e	103	method = COMP_zlib_oneshot();
b67cb09f TS	104	break;
	105	case TLSEXT_comp_cert_zstd:
	106	method = COMP_zstd_oneshot();
	107	break;
	108	default:
	109	goto err;
	110	}
	111
	112	if ((max_length = ossl_calculate_comp_expansion(alg, len)) == 0
	113	\|\| method == NULL
	114	\|\| (comp_ctx = COMP_CTX_new(method)) == NULL
	115	\|\| (comp_data = OPENSSL_zalloc(max_length)) == NULL)
	116	goto err;
	117
	118	comp_length = COMP_compress_block(comp_ctx, comp_data, max_length, data, len);
	119	if (comp_length <= 0)
	120	goto err;
	121
	122	ret = OSSL_COMP_CERT_new(comp_data, comp_length, len, alg);
	123	comp_data = NULL;
	124
	125	err:
	126	OPENSSL_free(comp_data);
	127	COMP_CTX_free(comp_ctx);
	128	return ret;
	129	}
	130
	131	void OSSL_COMP_CERT_free(OSSL_COMP_CERT *cc)
	132	{
	133	int i;
	134
	135	if (cc == NULL)
	136	return;
	137
43a07d6d	138	CRYPTO_DOWN_REF(&cc->references, &i);
b67cb09f TS	139	REF_PRINT_COUNT("OSSL_COMP_CERT", cc);
	140	if (i > 0)
	141	return;
	142	REF_ASSERT_ISNT(i < 0);
	143
	144	OPENSSL_free(cc->data);
43a07d6d	145	CRYPTO_FREE_REF(&cc->references);
b67cb09f TS	146	OPENSSL_free(cc);
	147	}
	148	int OSSL_COMP_CERT_up_ref(OSSL_COMP_CERT *cc)
	149	{
	150	int i;
	151
43a07d6d	152	if (CRYPTO_UP_REF(&cc->references, &i) <= 0)
b67cb09f TS	153	return 0;
	154
	155	REF_PRINT_COUNT("OSSL_COMP_CERT", cc);
	156	REF_ASSERT_ISNT(i < 2);
	157	return ((i > 1) ? 1 : 0);
	158	}
	159
	160	static int ssl_set_cert_comp_pref(int prefs, int algs, size_t len)
	161	{
	162	size_t j = 0;
	163	size_t i;
	164	int found = 0;
	165	int already_set[TLSEXT_comp_cert_limit];
	166	int tmp_prefs[TLSEXT_comp_cert_limit];
	167
	168	/* Note that \|len\| is the number of \|algs\| elements */
	169	/* clear all algorithms */
	170	if (len == 0 \|\| algs == NULL) {
	171	memset(prefs, 0, sizeof(tmp_prefs));
	172	return 1;
	173	}
	174
	175	/* This will 0-terminate the array */
	176	memset(tmp_prefs, 0, sizeof(tmp_prefs));
	177	memset(already_set, 0, sizeof(already_set));
	178	/* Include only those algorithms we support, ignoring duplicates and unknowns */
	179	for (i = 0; i < len; i++) {
	180	if (algs[i] != 0 && ossl_comp_has_alg(algs[i])) {
	181	/* Check for duplicate */
	182	if (already_set[algs[i]])
	183	return 0;
	184	tmp_prefs[j++] = algs[i];
	185	already_set[algs[i]] = 1;
	186	found = 1;
	187	}
	188	}
	189	if (found)
	190	memcpy(prefs, tmp_prefs, sizeof(tmp_prefs));
	191	return found;
	192	}
	193
	194	static size_t ssl_get_cert_to_compress(SSL ssl, CERT_PKEY cpk, unsigned char **data)
	195	{
	196	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
	197	WPACKET tmppkt;
	198	BUF_MEM buf = { 0 };
	199	size_t ret = 0;
b67cb09f TS	200
	201	if (sc == NULL
	202	\|\| cpk == NULL
	203	\|\| !sc->server
	204	\|\| !SSL_in_before(ssl))
	205	return 0;
	206
	207	/* Use the \|tmppkt\| for the to-be-compressed data */
	208	if (!WPACKET_init(&tmppkt, &buf))
	209	goto out;
	210
	211	/* no context present, add 0-length context */
	212	if (!WPACKET_put_bytes_u8(&tmppkt, 0))
	213	goto out;
	214
	215	/*
72620ac7 TS	216	* ssl3_output_cert_chain() may generate an SSLfatal() error,
72620ac7 TS	217	* for this case, we want to ignore it, argument for_comp = 1
b67cb09f	218	*/
72620ac7	219	if (!ssl3_output_cert_chain(sc, &tmppkt, cpk, 1))
b67cb09f TS	220	goto out;
	221	WPACKET_get_total_written(&tmppkt, &ret);
	222
	223	out:
b67cb09f TS	224	WPACKET_cleanup(&tmppkt);
	225	if (ret != 0 && data != NULL)
	226	data = (unsigned char )buf.data;
	227	else
	228	OPENSSL_free(buf.data);
	229	return ret;
	230	}
	231
	232	static int ssl_compress_one_cert(SSL ssl, CERT_PKEY cpk, int alg)
	233	{
	234	unsigned char *cert_data = NULL;
	235	OSSL_COMP_CERT *comp_cert = NULL;
	236	size_t length;
	237
	238	if (cpk == NULL
	239	\|\| alg == TLSEXT_comp_cert_none
	240	\|\| !ossl_comp_has_alg(alg))
	241	return 0;
	242
	243	if ((length = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
	244	return 0;
	245	comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, length, alg);
	246	OPENSSL_free(cert_data);
	247	if (comp_cert == NULL)
	248	return 0;
	249
	250	OSSL_COMP_CERT_free(cpk->comp_cert[alg]);
	251	cpk->comp_cert[alg] = comp_cert;
	252	return 1;
	253	}
	254
	255	/* alg_in can be 0, meaning any/all algorithms */
	256	static int ssl_compress_certs(SSL ssl, CERT_PKEY cpks, int alg_in)
	257	{
	258	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
	259	int i;
	260	int j;
	261	int alg;
	262	int count = 0;
	263
	264	if (sc == NULL
	265	\|\| cpks == NULL
	266	\|\| !ossl_comp_has_alg(alg_in))
	267	return 0;
	268
	269	/* Look through the preferences to see what we have */
	270	for (i = 0; i < TLSEXT_comp_cert_limit; i++) {
	271	/*
	272	* alg = 0 means compress for everything, but only for algorithms enabled
	273	* alg != 0 means compress for that algorithm if enabled
	274	*/
	275	alg = sc->cert_comp_prefs[i];
	276	if ((alg_in == 0 && alg != TLSEXT_comp_cert_none)
	277	\|\| (alg_in != 0 && alg == alg_in)) {
	278
	279	for (j = 0; j < SSL_PKEY_NUM; j++) {
	280	/* No cert, move on */
	281	if (cpks[j].x509 == NULL)
	282	continue;
	283
	284	if (!ssl_compress_one_cert(ssl, &cpks[j], alg))
	285	return 0;
	286
	287	/* if the cert expanded, set the value in the CERT_PKEY to NULL */
288	if (cpks[j].comp_cert[alg]->len >= cpks[j].comp_cert[alg]->orig_len) {
289	OSSL_COMP_CERT_free(cpks[j].comp_cert[alg]);
290	cpks[j].comp_cert[alg] = NULL;
291	} else {
292	count++;
293	}
294	}
295	}
296	}
297	return (count > 0);
298	}
299
300	static size_t ssl_get_compressed_cert(SSL ssl, CERT_PKEY cpk, int alg, unsigned char **data,
301	size_t *orig_len)
302	{
303	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
304	size_t cert_len = 0;
305	size_t comp_len = 0;
306	unsigned char *cert_data = NULL;
307	OSSL_COMP_CERT *comp_cert = NULL;
308
309	if (sc == NULL
310	\|\| cpk == NULL
311	\|\| data == NULL
312	\|\| orig_len == NULL
313	\|\| !sc->server
314	\|\| !SSL_in_before(ssl)
315	\|\| !ossl_comp_has_alg(alg))
316	return 0;
317
318	if ((cert_len = ssl_get_cert_to_compress(ssl, cpk, &cert_data)) == 0)
319	goto err;
320
321	comp_cert = OSSL_COMP_CERT_from_uncompressed_data(cert_data, cert_len, alg);
322	OPENSSL_free(cert_data);
323	if (comp_cert == NULL)
324	goto err;
325
326	comp_len = comp_cert->len;
327	*orig_len = comp_cert->orig_len;
328	*data = comp_cert->data;
329	comp_cert->data = NULL;
330	err:
331	OSSL_COMP_CERT_free(comp_cert);
332	return comp_len;
333	}
334
335	static int ossl_set1_compressed_cert(CERT *cert, int algorithm,
336	unsigned char *comp_data, size_t comp_length,
337	size_t orig_length)
338	{
339	OSSL_COMP_CERT *comp_cert;
340
341	/* No explicit cert set */
342	if (cert == NULL \|\| cert->key == NULL)
343	return 0;
344
345	comp_cert = OSSL_COMP_CERT_from_compressed_data(comp_data, comp_length,
346	orig_length, algorithm);
347	if (comp_cert == NULL)
348	return 0;
349
350	OSSL_COMP_CERT_free(cert->key->comp_cert[algorithm]);
351	cert->key->comp_cert[algorithm] = comp_cert;
352
353	return 1;
354	}
355	#endif
356
357	/*-
358	* Public API
359	*/
360	int SSL_CTX_set1_cert_comp_preference(SSL_CTX ctx, int algs, size_t len)
361	{
362	#ifndef OPENSSL_NO_COMP_ALG
363	return ssl_set_cert_comp_pref(ctx->cert_comp_prefs, algs, len);
364	#else
365	return 0;
366	#endif
367	}
368
369	int SSL_set1_cert_comp_preference(SSL ssl, int algs, size_t len)
370	{
371	#ifndef OPENSSL_NO_COMP_ALG
372	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
373
374	if (sc == NULL)
375	return 0;
376	return ssl_set_cert_comp_pref(sc->cert_comp_prefs, algs, len);
377	#else
378	return 0;
379	#endif
380	}
381
382	int SSL_compress_certs(SSL *ssl, int alg)
383	{
384	#ifndef OPENSSL_NO_COMP_ALG
385	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
386
387	if (sc == NULL \|\| sc->cert == NULL)
388	return 0;
389
390	return ssl_compress_certs(ssl, sc->cert->pkeys, alg);
391	#endif
392	return 0;
393	}
394
395	int SSL_CTX_compress_certs(SSL_CTX *ctx, int alg)
396	{
397	int ret = 0;
398	#ifndef OPENSSL_NO_COMP_ALG
399	SSL *new = SSL_new(ctx);
400
401	if (new == NULL)
402	return 0;
403
404	ret = ssl_compress_certs(new, ctx->cert->pkeys, alg);
405	SSL_free(new);
406	#endif
407	return ret;
408	}
409
410	size_t SSL_get1_compressed_cert(SSL ssl, int alg, unsigned char data, size_t orig_len)
411	{
412	#ifndef OPENSSL_NO_COMP_ALG
413	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
414	CERT_PKEY *cpk = NULL;
415
416	if (sc->cert != NULL)
417	cpk = sc->cert->key;
418	else
419	cpk = ssl->ctx->cert->key;
420
421	return ssl_get_compressed_cert(ssl, cpk, alg, data, orig_len);
422	#else
423	return 0;
424	#endif
425	}
426
427	size_t SSL_CTX_get1_compressed_cert(SSL_CTX ctx, int alg, unsigned char data, size_t orig_len)
428	{
429	#ifndef OPENSSL_NO_COMP_ALG
430	size_t ret;
431	SSL *new = SSL_new(ctx);
432
433	ret = ssl_get_compressed_cert(new, ctx->cert->key, alg, data, orig_len);
434	SSL_free(new);
435	return ret;
436	#else
437	return 0;
438	#endif
439	}
440
441	int SSL_CTX_set1_compressed_cert(SSL_CTX ctx, int algorithm, unsigned char comp_data,
442	size_t comp_length, size_t orig_length)
443	{
444	#ifndef OPENSSL_NO_COMP_ALG
445	return ossl_set1_compressed_cert(ctx->cert, algorithm, comp_data, comp_length, orig_length);
446	#else
447	return 0;
448	#endif
449	}
450
451	int SSL_set1_compressed_cert(SSL ssl, int algorithm, unsigned char comp_data,
452	size_t comp_length, size_t orig_length)
453	{
454	#ifndef OPENSSL_NO_COMP_ALG
455	SSL_CONNECTION *sc = SSL_CONNECTION_FROM_SSL(ssl);
456
457	/* Cannot set a pre-compressed certificate on a client */
458	if (sc == NULL \|\| !sc->server)
459	return 0;
460
461	return ossl_set1_compressed_cert(sc->cert, algorithm, comp_data, comp_length, orig_length);
462	#else
463	return 0;
464	#endif
465	}