/*

 * Copyright 1995-2020 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

 * https://www.openssl.org/source/license.html

 */

#include <stdio.h>

#include <stdlib.h>

#include <openssl/objects.h>

#include <openssl/evp.h>

#include <openssl/hmac.h>

#include <openssl/ocsp.h>

#include <openssl/conf.h>

#include <openssl/x509v3.h>

#include <openssl/dh.h>

#include <openssl/bn.h>

#include "internal/nelem.h"

#include "ssl_local.h"

#include <openssl/ct.h>

static const SIGALG_LOOKUP *find_sig_alg(SSL *s, X509 *x, EVP_PKEY *pkey);

static int tls12_sigalg_allowed(const SSL *s, int op, const SIGALG_LOOKUP *lu);

SSL3_ENC_METHOD const TLSv1_enc_data = {

    tls1_enc,

    tls1_mac,

    tls1_setup_key_block,

    tls1_generate_master_secret,

    tls1_change_cipher_state,

    tls1_final_finish_mac,

    TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,

    TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,

    tls1_alert_code,

    tls1_export_keying_material,

    0,

    ssl3_set_handshake_header,

    tls_close_construct_packet,

    ssl3_handshake_write

};

SSL3_ENC_METHOD const TLSv1_1_enc_data = {

    tls1_enc,

    tls1_mac,

    tls1_setup_key_block,

    tls1_generate_master_secret,

    tls1_change_cipher_state,

    tls1_final_finish_mac,

    TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,

    TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,

    tls1_alert_code,

    tls1_export_keying_material,

    SSL_ENC_FLAG_EXPLICIT_IV,

    ssl3_set_handshake_header,

    tls_close_construct_packet,

    ssl3_handshake_write

};

SSL3_ENC_METHOD const TLSv1_2_enc_data = {

    tls1_enc,

    tls1_mac,

    tls1_setup_key_block,

    tls1_generate_master_secret,

    tls1_change_cipher_state,

    tls1_final_finish_mac,

    TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,

    TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,

    tls1_alert_code,

    tls1_export_keying_material,

    SSL_ENC_FLAG_EXPLICIT_IV | SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF

        | SSL_ENC_FLAG_TLS1_2_CIPHERS,

    ssl3_set_handshake_header,

    tls_close_construct_packet,

    ssl3_handshake_write

};

SSL3_ENC_METHOD const TLSv1_3_enc_data = {

    tls13_enc,

    tls1_mac,

    tls13_setup_key_block,

    tls13_generate_master_secret,

    tls13_change_cipher_state,

    tls13_final_finish_mac,

    TLS_MD_CLIENT_FINISH_CONST, TLS_MD_CLIENT_FINISH_CONST_SIZE,

    TLS_MD_SERVER_FINISH_CONST, TLS_MD_SERVER_FINISH_CONST_SIZE,

    tls13_alert_code,

    tls13_export_keying_material,

    SSL_ENC_FLAG_SIGALGS | SSL_ENC_FLAG_SHA256_PRF,

    ssl3_set_handshake_header,

    tls_close_construct_packet,

    ssl3_handshake_write

};

long tls1_default_timeout(void)

{

    /*

     * 2 hours, the 24 hours mentioned in the TLSv1 spec is way too long for

     * http, the cache would over fill

     */

    return (60 * 60 * 2);

}

int tls1_new(SSL *s)

{

    if (!ssl3_new(s))

        return 0;

    if (!s->method->ssl_clear(s))

        return 0;

    return 1;

}

void tls1_free(SSL *s)

{

    OPENSSL_free(s->ext.session_ticket);

    ssl3_free(s);

}

int tls1_clear(SSL *s)

{

    if (!ssl3_clear(s))

        return 0;

    if (s->method->version == TLS_ANY_VERSION)

        s->version = TLS_MAX_VERSION;

    else

        s->version = s->method->version;

    return 1;

}

#ifndef OPENSSL_NO_EC

/*

 * Table of curve information.

 * Do not delete entries or reorder this array! It is used as a lookup

 * table: the index of each entry is one less than the TLS curve id.

 */

static const TLS_GROUP_INFO nid_list[] = {

    {NID_sect163k1, 80, TLS_CURVE_CHAR2}, /* sect163k1 (1) */

    {NID_sect163r1, 80, TLS_CURVE_CHAR2}, /* sect163r1 (2) */

    {NID_sect163r2, 80, TLS_CURVE_CHAR2}, /* sect163r2 (3) */

    {NID_sect193r1, 80, TLS_CURVE_CHAR2}, /* sect193r1 (4) */

    {NID_sect193r2, 80, TLS_CURVE_CHAR2}, /* sect193r2 (5) */

    {NID_sect233k1, 112, TLS_CURVE_CHAR2}, /* sect233k1 (6) */

    {NID_sect233r1, 112, TLS_CURVE_CHAR2}, /* sect233r1 (7) */

    {NID_sect239k1, 112, TLS_CURVE_CHAR2}, /* sect239k1 (8) */

    {NID_sect283k1, 128, TLS_CURVE_CHAR2}, /* sect283k1 (9) */

    {NID_sect283r1, 128, TLS_CURVE_CHAR2}, /* sect283r1 (10) */

    {NID_sect409k1, 192, TLS_CURVE_CHAR2}, /* sect409k1 (11) */

    {NID_sect409r1, 192, TLS_CURVE_CHAR2}, /* sect409r1 (12) */

    {NID_sect571k1, 256, TLS_CURVE_CHAR2}, /* sect571k1 (13) */

    {NID_sect571r1, 256, TLS_CURVE_CHAR2}, /* sect571r1 (14) */

    {NID_secp160k1, 80, TLS_CURVE_PRIME}, /* secp160k1 (15) */

    {NID_secp160r1, 80, TLS_CURVE_PRIME}, /* secp160r1 (16) */

    {NID_secp160r2, 80, TLS_CURVE_PRIME}, /* secp160r2 (17) */

    {NID_secp192k1, 80, TLS_CURVE_PRIME}, /* secp192k1 (18) */

    {NID_X9_62_prime192v1, 80, TLS_CURVE_PRIME}, /* secp192r1 (19) */

    {NID_secp224k1, 112, TLS_CURVE_PRIME}, /* secp224k1 (20) */

    {NID_secp224r1, 112, TLS_CURVE_PRIME | TLS_CURVE_FIPS}, /* secp224r1 (21) */

    {NID_secp256k1, 128, TLS_CURVE_PRIME}, /* secp256k1 (22) */

    {NID_X9_62_prime256v1, 128, TLS_CURVE_PRIME | TLS_CURVE_FIPS}, /* secp256r1 (23) */

    {NID_secp384r1, 192, TLS_CURVE_PRIME | TLS_CURVE_FIPS}, /* secp384r1 (24) */

    {NID_secp521r1, 256, TLS_CURVE_PRIME | TLS_CURVE_FIPS}, /* secp521r1 (25) */

    {NID_brainpoolP256r1, 128, TLS_CURVE_PRIME}, /* brainpoolP256r1 (26) */

    {NID_brainpoolP384r1, 192, TLS_CURVE_PRIME}, /* brainpoolP384r1 (27) */

    {NID_brainpoolP512r1, 256, TLS_CURVE_PRIME}, /* brainpool512r1 (28) */

    {EVP_PKEY_X25519, 128, TLS_CURVE_CUSTOM}, /* X25519 (29) */

    {EVP_PKEY_X448, 224, TLS_CURVE_CUSTOM}, /* X448 (30) */

};

static const unsigned char ecformats_default[] = {

    TLSEXT_ECPOINTFORMAT_uncompressed,

    TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime,

    TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2

};

/* The default curves */

static const uint16_t eccurves_default[] = {

    29,                      /* X25519 (29) */

    23,                      /* secp256r1 (23) */

    30,                      /* X448 (30) */

    25,                      /* secp521r1 (25) */

    24,                      /* secp384r1 (24) */

};

static const uint16_t suiteb_curves[] = {

    TLSEXT_curve_P_256,

    TLSEXT_curve_P_384

};

const TLS_GROUP_INFO *tls1_group_id_lookup(uint16_t group_id)

{

    /* ECC curves from RFC 4492 and RFC 7027 */

    if (group_id < 1 || group_id > OSSL_NELEM(nid_list))

        return NULL;

    return &nid_list[group_id - 1];

}

static uint16_t tls1_nid2group_id(int nid)

{

    size_t i;

    for (i = 0; i < OSSL_NELEM(nid_list); i++) {

        if (nid_list[i].nid == nid)

            return (uint16_t)(i + 1);

    }

    return 0;

}

/*

 * Set *pgroups to the supported groups list and *pgroupslen to

 * the number of groups supported.

 */

void tls1_get_supported_groups(SSL *s, const uint16_t **pgroups,

                               size_t *pgroupslen)

{

    /* For Suite B mode only include P-256, P-384 */

    switch (tls1_suiteb(s)) {

    case SSL_CERT_FLAG_SUITEB_128_LOS:

        *pgroups = suiteb_curves;

        *pgroupslen = OSSL_NELEM(suiteb_curves);

        break;

    case SSL_CERT_FLAG_SUITEB_128_LOS_ONLY:

        *pgroups = suiteb_curves;

        *pgroupslen = 1;

        break;

    case SSL_CERT_FLAG_SUITEB_192_LOS:

        *pgroups = suiteb_curves + 1;

        *pgroupslen = 1;

        break;

    default:

        if (s->ext.supportedgroups == NULL) {

            *pgroups = eccurves_default;

            *pgroupslen = OSSL_NELEM(eccurves_default);

        } else {

            *pgroups = s->ext.supportedgroups;

            *pgroupslen = s->ext.supportedgroups_len;

        }

        break;

    }

}

/* See if curve is allowed by security callback */

int tls_curve_allowed(SSL *s, uint16_t curve, int op)

{

    const TLS_GROUP_INFO *cinfo = tls1_group_id_lookup(curve);

    unsigned char ctmp[2];

    if (cinfo == NULL)

        return 0;

# ifdef OPENSSL_NO_EC2M

    if (cinfo->flags & TLS_CURVE_CHAR2)

        return 0;

# endif

    if (FIPS_mode() && !(cinfo->flags & TLS_CURVE_FIPS))

        return 0;

    ctmp[0] = curve >> 8;

    ctmp[1] = curve & 0xff;

    return ssl_security(s, op, cinfo->secbits, cinfo->nid, (void *)ctmp);

}

/* Return 1 if "id" is in "list" */

static int tls1_in_list(uint16_t id, const uint16_t *list, size_t listlen)

{

    size_t i;

    for (i = 0; i < listlen; i++)

        if (list[i] == id)

            return 1;

    return 0;

}

/*-

 * For nmatch >= 0, return the id of the |nmatch|th shared group or 0

 * if there is no match.

 * For nmatch == -1, return number of matches

 * For nmatch == -2, return the id of the group to use for

 * a tmp key, or 0 if there is no match.

 */

uint16_t tls1_shared_group(SSL *s, int nmatch)

{

    const uint16_t *pref, *supp;

    size_t num_pref, num_supp, i;

    int k;

    /* Can't do anything on client side */

    if (s->server == 0)

        return 0;

    if (nmatch == -2) {

        if (tls1_suiteb(s)) {

            /*

             * For Suite B ciphersuite determines curve: we already know

             * these are acceptable due to previous checks.

             */

            unsigned long cid = s->s3->tmp.new_cipher->id;

            if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)

                return TLSEXT_curve_P_256;

            if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)

                return TLSEXT_curve_P_384;

            /* Should never happen */

            return 0;

        }

        /* If not Suite B just return first preference shared curve */

        nmatch = 0;

    }

    /*

     * If server preference set, our groups are the preference order

     * otherwise peer decides.

     */

    if (s->options & SSL_OP_CIPHER_SERVER_PREFERENCE) {

        tls1_get_supported_groups(s, &pref, &num_pref);

        tls1_get_peer_groups(s, &supp, &num_supp);

    } else {

        tls1_get_peer_groups(s, &pref, &num_pref);

        tls1_get_supported_groups(s, &supp, &num_supp);

    }

    for (k = 0, i = 0; i < num_pref; i++) {

        uint16_t id = pref[i];

        if (!tls1_in_list(id, supp, num_supp)

            || !tls_curve_allowed(s, id, SSL_SECOP_CURVE_SHARED))

                    continue;

        if (nmatch == k)

            return id;

         k++;

    }

    if (nmatch == -1)

        return k;

    /* Out of range (nmatch > k). */

    return 0;

}

int tls1_set_groups(uint16_t **pext, size_t *pextlen,

                    int *groups, size_t ngroups)

{

    uint16_t *glist;

    size_t i;

    /*

     * Bitmap of groups included to detect duplicates: only works while group

     * ids < 32

     */

    unsigned long dup_list = 0;

    if (ngroups == 0) {

        SSLerr(SSL_F_TLS1_SET_GROUPS, SSL_R_BAD_LENGTH);

        return 0;

    }

    if ((glist = OPENSSL_malloc(ngroups * sizeof(*glist))) == NULL) {

        SSLerr(SSL_F_TLS1_SET_GROUPS, ERR_R_MALLOC_FAILURE);

        return 0;

    }

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

        unsigned long idmask;

        uint16_t id;

        /* TODO(TLS1.3): Convert for DH groups */

        id = tls1_nid2group_id(groups[i]);

        idmask = 1L << id;

        if (!id || (dup_list & idmask)) {

            OPENSSL_free(glist);

            return 0;

        }

        dup_list |= idmask;

        glist[i] = id;

    }

    OPENSSL_free(*pext);

    *pext = glist;

    *pextlen = ngroups;

    return 1;

}

# define MAX_CURVELIST   OSSL_NELEM(nid_list)

typedef struct {

    size_t nidcnt;

    int nid_arr[MAX_CURVELIST];

} nid_cb_st;

static int nid_cb(const char *elem, int len, void *arg)

{

    nid_cb_st *narg = arg;

    size_t i;

    int nid;

    char etmp[20];

    if (elem == NULL)

        return 0;

    if (narg->nidcnt == MAX_CURVELIST)

        return 0;

    if (len > (int)(sizeof(etmp) - 1))

        return 0;

    memcpy(etmp, elem, len);

    etmp[len] = 0;

    nid = EC_curve_nist2nid(etmp);

    if (nid == NID_undef)

        nid = OBJ_sn2nid(etmp);

    if (nid == NID_undef)

        nid = OBJ_ln2nid(etmp);

    if (nid == NID_undef)

        return 0;

    for (i = 0; i < narg->nidcnt; i++)

        if (narg->nid_arr[i] == nid)

            return 0;

    narg->nid_arr[narg->nidcnt++] = nid;

    return 1;

}

/* Set groups based on a colon separate list */

int tls1_set_groups_list(uint16_t **pext, size_t *pextlen, const char *str)

{

    nid_cb_st ncb;

    ncb.nidcnt = 0;

    if (!CONF_parse_list(str, ':', 1, nid_cb, &ncb))

        return 0;

    if (pext == NULL)

        return 1;

    return tls1_set_groups(pext, pextlen, ncb.nid_arr, ncb.nidcnt);

}

/* Return group id of a key */

static uint16_t tls1_get_group_id(EVP_PKEY *pkey)

{

    EC_KEY *ec = EVP_PKEY_get0_EC_KEY(pkey);

    const EC_GROUP *grp;

    if (ec == NULL)

        return 0;

    grp = EC_KEY_get0_group(ec);

    return tls1_nid2group_id(EC_GROUP_get_curve_name(grp));

}

/* Check a key is compatible with compression extension */

static int tls1_check_pkey_comp(SSL *s, EVP_PKEY *pkey)

{

    const EC_KEY *ec;

    const EC_GROUP *grp;

    unsigned char comp_id;

    size_t i;

    /* If not an EC key nothing to check */

    if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)

        return 1;

    ec = EVP_PKEY_get0_EC_KEY(pkey);

    grp = EC_KEY_get0_group(ec);

    /* Get required compression id */

    if (EC_KEY_get_conv_form(ec) == POINT_CONVERSION_UNCOMPRESSED) {

            comp_id = TLSEXT_ECPOINTFORMAT_uncompressed;

    } else if (SSL_IS_TLS13(s)) {

            /*

             * ec_point_formats extension is not used in TLSv1.3 so we ignore

             * this check.

             */

            return 1;

    } else {

        int field_type = EC_METHOD_get_field_type(EC_GROUP_method_of(grp));

        if (field_type == NID_X9_62_prime_field)

            comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;

        else if (field_type == NID_X9_62_characteristic_two_field)

            comp_id = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;

        else

            return 0;

    }

    /*

     * If point formats extension present check it, otherwise everything is

     * supported (see RFC4492).

     */

    if (s->ext.peer_ecpointformats == NULL)

        return 1;

    for (i = 0; i < s->ext.peer_ecpointformats_len; i++) {

        if (s->ext.peer_ecpointformats[i] == comp_id)

            return 1;

    }

    return 0;

}

/* Check a group id matches preferences */

int tls1_check_group_id(SSL *s, uint16_t group_id, int check_own_groups)

    {

    const uint16_t *groups;

    size_t groups_len;

    if (group_id == 0)

        return 0;

    /* Check for Suite B compliance */

    if (tls1_suiteb(s) && s->s3->tmp.new_cipher != NULL) {

        unsigned long cid = s->s3->tmp.new_cipher->id;

        if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256) {

            if (group_id != TLSEXT_curve_P_256)

                return 0;

        } else if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384) {

            if (group_id != TLSEXT_curve_P_384)

                return 0;

        } else {

            /* Should never happen */

            return 0;

        }

    }

    if (check_own_groups) {

        /* Check group is one of our preferences */

        tls1_get_supported_groups(s, &groups, &groups_len);

        if (!tls1_in_list(group_id, groups, groups_len))

            return 0;

    }

    if (!tls_curve_allowed(s, group_id, SSL_SECOP_CURVE_CHECK))

        return 0;

    /* For clients, nothing more to check */

    if (!s->server)

        return 1;

    /* Check group is one of peers preferences */

    tls1_get_peer_groups(s, &groups, &groups_len);

    /*

     * RFC 4492 does not require the supported elliptic curves extension

     * so if it is not sent we can just choose any curve.

     * It is invalid to send an empty list in the supported groups

     * extension, so groups_len == 0 always means no extension.

     */

    if (groups_len == 0)

            return 1;

    return tls1_in_list(group_id, groups, groups_len);

}

void tls1_get_formatlist(SSL *s, const unsigned char **pformats,

                         size_t *num_formats)

{

    /*

     * If we have a custom point format list use it otherwise use default

     */

    if (s->ext.ecpointformats) {

        *pformats = s->ext.ecpointformats;

        *num_formats = s->ext.ecpointformats_len;

    } else {

        *pformats = ecformats_default;

        /* For Suite B we don't support char2 fields */

        if (tls1_suiteb(s))

            *num_formats = sizeof(ecformats_default) - 1;

        else

            *num_formats = sizeof(ecformats_default);

    }

}

/*

 * Check cert parameters compatible with extensions: currently just checks EC

 * certificates have compatible curves and compression.

 */

static int tls1_check_cert_param(SSL *s, X509 *x, int check_ee_md)

{

    uint16_t group_id;

    EVP_PKEY *pkey;

    pkey = X509_get0_pubkey(x);

    if (pkey == NULL)

        return 0;

    /* If not EC nothing to do */

    if (EVP_PKEY_id(pkey) != EVP_PKEY_EC)

        return 1;

    /* Check compression */

    if (!tls1_check_pkey_comp(s, pkey))

        return 0;

    group_id = tls1_get_group_id(pkey);

    /*

     * For a server we allow the certificate to not be in our list of supported

     * groups.

     */

    if (!tls1_check_group_id(s, group_id, !s->server))

        return 0;

    /*

     * Special case for suite B. We *MUST* sign using SHA256+P-256 or

     * SHA384+P-384.

     */

    if (check_ee_md && tls1_suiteb(s)) {

        int check_md;

        size_t i;

        /* Check to see we have necessary signing algorithm */

        if (group_id == TLSEXT_curve_P_256)

            check_md = NID_ecdsa_with_SHA256;

        else if (group_id == TLSEXT_curve_P_384)

            check_md = NID_ecdsa_with_SHA384;

        else

            return 0;           /* Should never happen */

        for (i = 0; i < s->shared_sigalgslen; i++) {

            if (check_md == s->shared_sigalgs[i]->sigandhash)

                return 1;;

        }

        return 0;

    }

    return 1;

}

/*

 * tls1_check_ec_tmp_key - Check EC temporary key compatibility

 * @s: SSL connection

 * @cid: Cipher ID we're considering using

 *

 * Checks that the kECDHE cipher suite we're considering using

 * is compatible with the client extensions.

 *

 * Returns 0 when the cipher can't be used or 1 when it can.

 */

int tls1_check_ec_tmp_key(SSL *s, unsigned long cid)

{

    /* If not Suite B just need a shared group */

    if (!tls1_suiteb(s))

        return tls1_shared_group(s, 0) != 0;

    /*

     * If Suite B, AES128 MUST use P-256 and AES256 MUST use P-384, no other

     * curves permitted.

     */

    if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256)

        return tls1_check_group_id(s, TLSEXT_curve_P_256, 1);

    if (cid == TLS1_CK_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384)

        return tls1_check_group_id(s, TLSEXT_curve_P_384, 1);

    return 0;

}

#else

static int tls1_check_cert_param(SSL *s, X509 *x, int set_ee_md)

{

    return 1;

}

#endif                          /* OPENSSL_NO_EC */

/* Default sigalg schemes */

static const uint16_t tls12_sigalgs[] = {

#ifndef OPENSSL_NO_EC

    TLSEXT_SIGALG_ecdsa_secp256r1_sha256,

    TLSEXT_SIGALG_ecdsa_secp384r1_sha384,

    TLSEXT_SIGALG_ecdsa_secp521r1_sha512,

    TLSEXT_SIGALG_ed25519,

    TLSEXT_SIGALG_ed448,

#endif

    TLSEXT_SIGALG_rsa_pss_pss_sha256,

    TLSEXT_SIGALG_rsa_pss_pss_sha384,

    TLSEXT_SIGALG_rsa_pss_pss_sha512,

    TLSEXT_SIGALG_rsa_pss_rsae_sha256,

    TLSEXT_SIGALG_rsa_pss_rsae_sha384,

    TLSEXT_SIGALG_rsa_pss_rsae_sha512,

    TLSEXT_SIGALG_rsa_pkcs1_sha256,

    TLSEXT_SIGALG_rsa_pkcs1_sha384,

    TLSEXT_SIGALG_rsa_pkcs1_sha512,

#ifndef OPENSSL_NO_EC

    TLSEXT_SIGALG_ecdsa_sha224,

    TLSEXT_SIGALG_ecdsa_sha1,

#endif

    TLSEXT_SIGALG_rsa_pkcs1_sha224,

    TLSEXT_SIGALG_rsa_pkcs1_sha1,

#ifndef OPENSSL_NO_DSA

    TLSEXT_SIGALG_dsa_sha224,

    TLSEXT_SIGALG_dsa_sha1,

    TLSEXT_SIGALG_dsa_sha256,

    TLSEXT_SIGALG_dsa_sha384,

    TLSEXT_SIGALG_dsa_sha512,

#endif

#ifndef OPENSSL_NO_GOST

    TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,

    TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,

    TLSEXT_SIGALG_gostr34102001_gostr3411,

#endif

};

static const uint16_t tls12_fips_sigalgs[] = {

#ifndef OPENSSL_NO_EC

    TLSEXT_SIGALG_ecdsa_secp256r1_sha256,

    TLSEXT_SIGALG_ecdsa_secp384r1_sha384,

    TLSEXT_SIGALG_ecdsa_secp521r1_sha512,

#endif

    TLSEXT_SIGALG_rsa_pss_pss_sha256,

    TLSEXT_SIGALG_rsa_pss_pss_sha384,

    TLSEXT_SIGALG_rsa_pss_pss_sha512,

    TLSEXT_SIGALG_rsa_pss_rsae_sha256,

    TLSEXT_SIGALG_rsa_pss_rsae_sha384,

    TLSEXT_SIGALG_rsa_pss_rsae_sha512,

    TLSEXT_SIGALG_rsa_pkcs1_sha256,

    TLSEXT_SIGALG_rsa_pkcs1_sha384,

    TLSEXT_SIGALG_rsa_pkcs1_sha512,

#ifndef OPENSSL_NO_EC

    TLSEXT_SIGALG_ecdsa_sha224,

#endif

    TLSEXT_SIGALG_rsa_pkcs1_sha224,

#ifndef OPENSSL_NO_DSA

    TLSEXT_SIGALG_dsa_sha224,

    TLSEXT_SIGALG_dsa_sha256,

    TLSEXT_SIGALG_dsa_sha384,

    TLSEXT_SIGALG_dsa_sha512,

#endif

};

#ifndef OPENSSL_NO_EC

static const uint16_t suiteb_sigalgs[] = {

    TLSEXT_SIGALG_ecdsa_secp256r1_sha256,

    TLSEXT_SIGALG_ecdsa_secp384r1_sha384

};

#endif

static const SIGALG_LOOKUP sigalg_lookup_tbl[] = {

#ifndef OPENSSL_NO_EC

    {"ecdsa_secp256r1_sha256", TLSEXT_SIGALG_ecdsa_secp256r1_sha256,

     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,

     NID_ecdsa_with_SHA256, NID_X9_62_prime256v1},

    {"ecdsa_secp384r1_sha384", TLSEXT_SIGALG_ecdsa_secp384r1_sha384,

     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,

     NID_ecdsa_with_SHA384, NID_secp384r1},

    {"ecdsa_secp521r1_sha512", TLSEXT_SIGALG_ecdsa_secp521r1_sha512,

     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,

     NID_ecdsa_with_SHA512, NID_secp521r1},

    {"ed25519", TLSEXT_SIGALG_ed25519,

     NID_undef, -1, EVP_PKEY_ED25519, SSL_PKEY_ED25519,

     NID_undef, NID_undef},

    {"ed448", TLSEXT_SIGALG_ed448,

     NID_undef, -1, EVP_PKEY_ED448, SSL_PKEY_ED448,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_ecdsa_sha224,

     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,

     NID_ecdsa_with_SHA224, NID_undef},

    {NULL, TLSEXT_SIGALG_ecdsa_sha1,

     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_EC, SSL_PKEY_ECC,

     NID_ecdsa_with_SHA1, NID_undef},

#endif

    {"rsa_pss_rsae_sha256", TLSEXT_SIGALG_rsa_pss_rsae_sha256,

     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,

     NID_undef, NID_undef},

    {"rsa_pss_rsae_sha384", TLSEXT_SIGALG_rsa_pss_rsae_sha384,

     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,

     NID_undef, NID_undef},

    {"rsa_pss_rsae_sha512", TLSEXT_SIGALG_rsa_pss_rsae_sha512,

     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA,

     NID_undef, NID_undef},

    {"rsa_pss_pss_sha256", TLSEXT_SIGALG_rsa_pss_pss_sha256,

     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,

     NID_undef, NID_undef},

    {"rsa_pss_pss_sha384", TLSEXT_SIGALG_rsa_pss_pss_sha384,

     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,

     NID_undef, NID_undef},

    {"rsa_pss_pss_sha512", TLSEXT_SIGALG_rsa_pss_pss_sha512,

     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA_PSS, SSL_PKEY_RSA_PSS_SIGN,

     NID_undef, NID_undef},

    {"rsa_pkcs1_sha256", TLSEXT_SIGALG_rsa_pkcs1_sha256,

     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_sha256WithRSAEncryption, NID_undef},

    {"rsa_pkcs1_sha384", TLSEXT_SIGALG_rsa_pkcs1_sha384,

     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_sha384WithRSAEncryption, NID_undef},

    {"rsa_pkcs1_sha512", TLSEXT_SIGALG_rsa_pkcs1_sha512,

     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_sha512WithRSAEncryption, NID_undef},

    {"rsa_pkcs1_sha224", TLSEXT_SIGALG_rsa_pkcs1_sha224,

     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_sha224WithRSAEncryption, NID_undef},

    {"rsa_pkcs1_sha1", TLSEXT_SIGALG_rsa_pkcs1_sha1,

     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_sha1WithRSAEncryption, NID_undef},

#ifndef OPENSSL_NO_DSA

    {NULL, TLSEXT_SIGALG_dsa_sha256,

     NID_sha256, SSL_MD_SHA256_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,

     NID_dsa_with_SHA256, NID_undef},

    {NULL, TLSEXT_SIGALG_dsa_sha384,

     NID_sha384, SSL_MD_SHA384_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_dsa_sha512,

     NID_sha512, SSL_MD_SHA512_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_dsa_sha224,

     NID_sha224, SSL_MD_SHA224_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_dsa_sha1,

     NID_sha1, SSL_MD_SHA1_IDX, EVP_PKEY_DSA, SSL_PKEY_DSA_SIGN,

     NID_dsaWithSHA1, NID_undef},

#endif

#ifndef OPENSSL_NO_GOST

    {NULL, TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256,

     NID_id_GostR3411_2012_256, SSL_MD_GOST12_256_IDX,

     NID_id_GostR3410_2012_256, SSL_PKEY_GOST12_256,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512,

     NID_id_GostR3411_2012_512, SSL_MD_GOST12_512_IDX,

     NID_id_GostR3410_2012_512, SSL_PKEY_GOST12_512,

     NID_undef, NID_undef},

    {NULL, TLSEXT_SIGALG_gostr34102001_gostr3411,

     NID_id_GostR3411_94, SSL_MD_GOST94_IDX,

     NID_id_GostR3410_2001, SSL_PKEY_GOST01,

     NID_undef, NID_undef}

#endif

};

/* Legacy sigalgs for TLS < 1.2 RSA TLS signatures */

static const SIGALG_LOOKUP legacy_rsa_sigalg = {

    "rsa_pkcs1_md5_sha1", 0,

     NID_md5_sha1, SSL_MD_MD5_SHA1_IDX,

     EVP_PKEY_RSA, SSL_PKEY_RSA,

     NID_undef, NID_undef

};

/*

 * Default signature algorithm values used if signature algorithms not present.

 * From RFC5246. Note: order must match certificate index order.

 */

static const uint16_t tls_default_sigalg[] = {

    TLSEXT_SIGALG_rsa_pkcs1_sha1, /* SSL_PKEY_RSA */

    0, /* SSL_PKEY_RSA_PSS_SIGN */

    TLSEXT_SIGALG_dsa_sha1, /* SSL_PKEY_DSA_SIGN */

    TLSEXT_SIGALG_ecdsa_sha1, /* SSL_PKEY_ECC */

    TLSEXT_SIGALG_gostr34102001_gostr3411, /* SSL_PKEY_GOST01 */

    TLSEXT_SIGALG_gostr34102012_256_gostr34112012_256, /* SSL_PKEY_GOST12_256 */

    TLSEXT_SIGALG_gostr34102012_512_gostr34112012_512, /* SSL_PKEY_GOST12_512 */

    0, /* SSL_PKEY_ED25519 */

    0, /* SSL_PKEY_ED448 */

};

/* Lookup TLS signature algorithm */

static const SIGALG_LOOKUP *tls1_lookup_sigalg(uint16_t sigalg)

{

    size_t i;

    const SIGALG_LOOKUP *s;

    for (i = 0, s = sigalg_lookup_tbl; i < OSSL_NELEM(sigalg_lookup_tbl);

         i++, s++) {

        if (s->sigalg == sigalg)

            return s;

    }

    return NULL;

}

/* Lookup hash: return 0 if invalid or not enabled */

int tls1_lookup_md(const SIGALG_LOOKUP *lu, const EVP_MD **pmd)

{

    const EVP_MD *md;

    if (lu == NULL)

        return 0;

    /* lu->hash == NID_undef means no associated digest */

    if (lu->hash == NID_undef) {

        md = NULL;

    } else {

        md = ssl_md(lu->hash_idx);

        if (md == NULL)

            return 0;

    }

    if (pmd)

        *pmd = md;

    return 1;

}

/*

 * Check if key is large enough to generate RSA-PSS signature.

 *

 * The key must greater than or equal to 2 * hash length + 2.

 * SHA512 has a hash length of 64 bytes, which is incompatible

 * with a 128 byte (1024 bit) key.

 */

#define RSA_PSS_MINIMUM_KEY_SIZE(md) (2 * EVP_MD_size(md) + 2)

static int rsa_pss_check_min_key_size(const RSA *rsa, const SIGALG_LOOKUP *lu)

{

    const EVP_MD *md;

    if (rsa == NULL)

        return 0;

    if (!tls1_lookup_md(lu, &md) || md == NULL)

        return 0;

    if (RSA_size(rsa) < RSA_PSS_MINIMUM_KEY_SIZE(md))

        return 0;