ssl/statem/extensions_clnt.c

   1 /*
   2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 <assert.h>
  11 #include <openssl/ocsp.h>
  12 #include "../ssl_locl.h"
  13 #include "statem_locl.h"
  14
  15 int tls_construct_client_renegotiate(SSL *s, WPACKET *pkt, int *al)
  16 {
  17     /* Add RI if renegotiating */
  18     if (!s->renegotiate)
  19         return 1;
  20
  21     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
  22             || !WPACKET_start_sub_packet_u16(pkt)
  23             || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
  24                                s->s3->previous_client_finished_len)
  25             || !WPACKET_close(pkt)) {
  26         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
  27         return 0;
  28     }
  29
  30     return 1;
  31 }
  32
  33 int tls_construct_client_server_name(SSL *s, WPACKET *pkt, int *al)
  34 {
  35     if (s->tlsext_hostname == NULL)
  36         return 1;
  37
  38     /* Add TLS extension servername to the Client Hello message */
  39     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
  40                /* Sub-packet for server_name extension */
  41             || !WPACKET_start_sub_packet_u16(pkt)
  42                /* Sub-packet for servername list (always 1 hostname)*/
  43             || !WPACKET_start_sub_packet_u16(pkt)
  44             || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
  45             || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
  46                                        strlen(s->tlsext_hostname))
  47             || !WPACKET_close(pkt)
  48             || !WPACKET_close(pkt)) {
  49         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SERVER_NAME, ERR_R_INTERNAL_ERROR);
  50         return 0;
  51     }
  52
  53     return 1;
  54 }
  55
  56 #ifndef OPENSSL_NO_SRP
  57 int tls_construct_client_srp(SSL *s, WPACKET *pkt, int *al)
  58 {
  59     /* Add SRP username if there is one */
  60     if (s->srp_ctx.login == NULL)
  61         return 1;
  62
  63     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
  64                /* Sub-packet for SRP extension */
  65             || !WPACKET_start_sub_packet_u16(pkt)
  66             || !WPACKET_start_sub_packet_u8(pkt)
  67                /* login must not be zero...internal error if so */
  68             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
  69             || !WPACKET_memcpy(pkt, s->srp_ctx.login,
  70                                strlen(s->srp_ctx.login))
  71             || !WPACKET_close(pkt)
  72             || !WPACKET_close(pkt)) {
  73         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SRP, ERR_R_INTERNAL_ERROR);
  74         return 0;
  75     }
  76
  77     return 1;
  78 }
  79 #endif
  80
  81 #ifndef OPENSSL_NO_EC
  82 static int use_ecc(SSL *s)
  83 {
  84     int using_ecc = 0;
  85     int i;
  86     unsigned long alg_k, alg_a;
  87     STACK_OF(SSL_CIPHER) *cipher_stack = NULL;
  88
  89     /* See if we support any ECC ciphersuites */
  90     if (s->version == SSL3_VERSION)
  91         return 0;
  92
  93
  94     cipher_stack = SSL_get_ciphers(s);
  95
  96     for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
  97         const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
  98
  99         alg_k = c->algorithm_mkey;
 100         alg_a = c->algorithm_auth;
 101         if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
 102             || (alg_a & SSL_aECDSA)
 103             || c->min_tls >= TLS1_3_VERSION) {
 104             using_ecc = 1;
 105             break;
 106         }
 107     }
 108
 109     return using_ecc;
 110 }
 111
 112 int tls_construct_client_ec_pt_formats(SSL *s, WPACKET *pkt, int *al)
 113 {
 114     const unsigned char *pformats;
 115     size_t num_formats;
 116
 117     if (!use_ecc(s))
 118         return 1;
 119
 120     /* Add TLS extension ECPointFormats to the ClientHello message */
 121
 122     tls1_get_formatlist(s, &pformats, &num_formats);
 123
 124     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
 125                /* Sub-packet for formats extension */
 126             || !WPACKET_start_sub_packet_u16(pkt)
 127             || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
 128             || !WPACKET_close(pkt)) {
 129         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
 130         return 0;
 131     }
 132
 133     return 1;
 134 }
 135
 136
 137 int tls_construct_client_supported_groups(SSL *s, WPACKET *pkt, int *al)
 138 {
 139     const unsigned char *pcurves = NULL, *pcurvestmp;
 140     size_t num_curves = 0, i;
 141
 142     if (!use_ecc(s))
 143         return 1;
 144
 145     /*
 146      * Add TLS extension supported_groups to the ClientHello message
 147      */
 148     /* TODO(TLS1.3): Add support for DHE groups */
 149     pcurves = s->tlsext_supportedgroupslist;
 150     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
 151         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
 152                ERR_R_INTERNAL_ERROR);
 153         return 0;
 154     }
 155     pcurvestmp = pcurves;
 156
 157     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
 158                /* Sub-packet for supported_groups extension */
 159             || !WPACKET_start_sub_packet_u16(pkt)
 160             || !WPACKET_start_sub_packet_u16(pkt)) {
 161         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
 162                ERR_R_INTERNAL_ERROR);
 163         return 0;
 164     }
 165     /* Copy curve ID if supported */
 166     for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
 167         if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
 168             if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
 169                 || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
 170                     SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
 171                            ERR_R_INTERNAL_ERROR);
 172                     return 0;
 173                 }
 174         }
 175     }
 176     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 177         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
 178                ERR_R_INTERNAL_ERROR);
 179         return 0;
 180     }
 181
 182     return 1;
 183 }
 184 #endif
 185
 186 int tls_construct_client_session_ticket(SSL *s, WPACKET *pkt, int *al)
 187 {
 188     size_t ticklen;
 189
 190     if (!tls_use_ticket(s))
 191         return 1;
 192
 193     if (!s->new_session && s->session != NULL
 194             && s->session->tlsext_tick != NULL) {
 195         ticklen = s->session->tlsext_ticklen;
 196     } else if (s->session && s->tlsext_session_ticket != NULL
 197                && s->tlsext_session_ticket->data != NULL) {
 198         ticklen = s->tlsext_session_ticket->length;
 199         s->session->tlsext_tick = OPENSSL_malloc(ticklen);
 200         if (s->session->tlsext_tick == NULL) {
 201             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SESSION_TICKET,
 202                    ERR_R_INTERNAL_ERROR);
 203             return 0;
 204         }
 205         memcpy(s->session->tlsext_tick,
 206                s->tlsext_session_ticket->data, ticklen);
 207         s->session->tlsext_ticklen = ticklen;
 208     } else {
 209         ticklen = 0;
 210     }
 211
 212     if (ticklen == 0 && s->tlsext_session_ticket != NULL &&
 213             s->tlsext_session_ticket->data == NULL)
 214         return 1;
 215
 216     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
 217             || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick, ticklen)) {
 218         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
 219         return 0;
 220     }
 221
 222     return 1;
 223 }
 224
 225 int tls_construct_client_sig_algs(SSL *s, WPACKET *pkt, int *al)
 226 {
 227     size_t salglen;
 228     const unsigned char *salg;
 229
 230     if (!SSL_CLIENT_USE_SIGALGS(s))
 231         return 1;
 232
 233     salglen = tls12_get_psigalgs(s, &salg);
 234
 235     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
 236                /* Sub-packet for sig-algs extension */
 237             || !WPACKET_start_sub_packet_u16(pkt)
 238                /* Sub-packet for the actual list */
 239             || !WPACKET_start_sub_packet_u16(pkt)
 240             || !tls12_copy_sigalgs(s, pkt, salg, salglen)
 241             || !WPACKET_close(pkt)
 242             || !WPACKET_close(pkt)) {
 243         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SIG_ALGS, ERR_R_INTERNAL_ERROR);
 244         return 0;
 245     }
 246
 247     return 1;
 248 }
 249
 250 #ifndef OPENSSL_NO_OCSP
 251 int tls_construct_client_status_request(SSL *s, WPACKET *pkt, int *al)
 252 {
 253     int i;
 254
 255     if (s->tlsext_status_type != TLSEXT_STATUSTYPE_ocsp)
 256         return 1;
 257
 258     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
 259                /* Sub-packet for status request extension */
 260             || !WPACKET_start_sub_packet_u16(pkt)
 261             || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
 262                /* Sub-packet for the ids */
 263             || !WPACKET_start_sub_packet_u16(pkt)) {
 264         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 265         return 0;
 266     }
 267     for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
 268         unsigned char *idbytes;
 269         int idlen;
 270         OCSP_RESPID *id;
 271
 272         id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
 273         idlen = i2d_OCSP_RESPID(id, NULL);
 274         if (idlen <= 0
 275                    /* Sub-packet for an individual id */
 276                 || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
 277                 || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
 278             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
 279                    ERR_R_INTERNAL_ERROR);
 280             return 0;
 281         }
 282     }
 283     if (!WPACKET_close(pkt)
 284             || !WPACKET_start_sub_packet_u16(pkt)) {
 285         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 286         return 0;
 287     }
 288     if (s->tlsext_ocsp_exts) {
 289         unsigned char *extbytes;
 290         int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
 291
 292         if (extlen < 0) {
 293             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
 294                    ERR_R_INTERNAL_ERROR);
 295             return 0;
 296         }
 297         if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
 298                 || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
 299                    != extlen) {
 300             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
 301                    ERR_R_INTERNAL_ERROR);
 302             return 0;
 303        }
 304     }
 305     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 306         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 307         return 0;
 308     }
 309
 310     return 1;
 311 }
 312 #endif
 313
 314 #ifndef OPENSSL_NO_NEXTPROTONEG
 315 int tls_construct_client_npn(SSL *s, WPACKET *pkt, int *al)
 316 {
 317     if (s->ctx->next_proto_select_cb == NULL || s->s3->tmp.finish_md_len != 0)
 318         return 1;
 319
 320     /*
 321      * The client advertises an empty extension to indicate its support
 322      * for Next Protocol Negotiation
 323      */
 324     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
 325             || !WPACKET_put_bytes_u16(pkt, 0)) {
 326         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_NPN, ERR_R_INTERNAL_ERROR);
 327         return 0;
 328     }
 329
 330     return 1;
 331 }
 332 #endif
 333
 334 int tls_construct_client_alpn(SSL *s, WPACKET *pkt, int *al)
 335 {
 336     s->s3->alpn_sent = 0;
 337
 338     /*
 339      * finish_md_len is non-zero during a renegotiation, so
 340      * this avoids sending ALPN during the renegotiation
 341      */
 342     if (s->alpn_client_proto_list == NULL || s->s3->tmp.finish_md_len != 0)
 343         return 1;
 344
 345     if (!WPACKET_put_bytes_u16(pkt,
 346                 TLSEXT_TYPE_application_layer_protocol_negotiation)
 347                /* Sub-packet ALPN extension */
 348             || !WPACKET_start_sub_packet_u16(pkt)
 349             || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
 350                                        s->alpn_client_proto_list_len)
 351             || !WPACKET_close(pkt)) {
 352         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_ALPN, ERR_R_INTERNAL_ERROR);
 353         return 0;
 354     }
 355     s->s3->alpn_sent = 1;
 356
 357     return 1;
 358 }
 359
 360
 361 #ifndef OPENSSL_NO_SRTP
 362 int tls_construct_client_use_srtp(SSL *s, WPACKET *pkt, int *al)
 363 {
 364     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
 365     SRTP_PROTECTION_PROFILE *prof;
 366     int i, ct;
 367
 368     if (clnt == NULL)
 369         return 1;
 370
 371     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
 372                /* Sub-packet for SRTP extension */
 373             || !WPACKET_start_sub_packet_u16(pkt)
 374                /* Sub-packet for the protection profile list */
 375             || !WPACKET_start_sub_packet_u16(pkt)) {
 376         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
 377         return 0;
 378     }
 379     ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
 380     for (i = 0; i < ct; i++) {
 381         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
 382         if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
 383             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
 384             return 0;
 385         }
 386     }
 387     if (!WPACKET_close(pkt)
 388                /* Add an empty use_mki value */
 389             || !WPACKET_put_bytes_u8(pkt, 0)
 390             || !WPACKET_close(pkt)) {
 391         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
 392         return 0;
 393     }
 394
 395     return 1;
 396 }
 397 #endif
 398
 399 int tls_construct_client_etm(SSL *s, WPACKET *pkt, int *al)
 400 {
 401     if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
 402         return 1;
 403
 404     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
 405             || !WPACKET_put_bytes_u16(pkt, 0)) {
 406         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_ETM, ERR_R_INTERNAL_ERROR);
 407         return 0;
 408     }
 409
 410     return 1;
 411 }
 412
 413 #ifndef OPENSSL_NO_CT
 414 int tls_construct_client_sct(SSL *s, WPACKET *pkt, int *al)
 415 {
 416     if (s->ct_validation_callback == NULL)
 417         return 1;
 418
 419     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
 420             || !WPACKET_put_bytes_u16(pkt, 0)) {
 421         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SCT, ERR_R_INTERNAL_ERROR);
 422         return 0;
 423     }
 424
 425     return 1;
 426 }
 427 #endif
 428
 429 int tls_construct_client_ems(SSL *s, WPACKET *pkt, int *al)
 430 {
 431     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
 432             || !WPACKET_put_bytes_u16(pkt, 0)) {
 433         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_EMS, ERR_R_INTERNAL_ERROR);
 434         return 0;
 435     }
 436
 437     return 1;
 438 }
 439
 440 int tls_construct_client_supported_versions(SSL *s, WPACKET *pkt, int *al)
 441 {
 442     int currv, min_version, max_version, reason;
 443
 444     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
 445             || !WPACKET_start_sub_packet_u16(pkt)
 446             || !WPACKET_start_sub_packet_u8(pkt)) {
 447         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
 448                ERR_R_INTERNAL_ERROR);
 449         return 0;
 450     }
 451
 452     reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
 453     if (reason != 0) {
 454         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS, reason);
 455         return 0;
 456     }
 457
 458     /*
 459      * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
 460      * we should include versions <TLS1.2. For the moment we do. To be
 461      * reviewed later.
 462      */
 463     for (currv = max_version; currv >= min_version; currv--) {
 464         /* TODO(TLS1.3): Remove this first if clause prior to release!! */
 465         if (currv == TLS1_3_VERSION) {
 466             if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
 467                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
 468                        ERR_R_INTERNAL_ERROR);
 469                 return 0;
 470             }
 471         } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
 472             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
 473                    ERR_R_INTERNAL_ERROR);
 474             return 0;
 475         }
 476     }
 477     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 478         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
 479                ERR_R_INTERNAL_ERROR);
 480         return 0;
 481     }
 482
 483     return 1;
 484 }
 485
 486
 487 int tls_construct_client_key_share(SSL *s, WPACKET *pkt, int *al)
 488 {
 489     size_t i, sharessent = 0, num_curves = 0;
 490     const unsigned char *pcurves = NULL;
 491
 492     /* key_share extension */
 493     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
 494                /* Extension data sub-packet */
 495             || !WPACKET_start_sub_packet_u16(pkt)
 496                /* KeyShare list sub-packet */
 497             || !WPACKET_start_sub_packet_u16(pkt)) {
 498         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 499         return 0;
 500     }
 501
 502     pcurves = s->tlsext_supportedgroupslist;
 503     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
 504         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 505         return 0;
 506     }
 507
 508     /*
 509      * TODO(TLS1.3): Make the number of key_shares sent configurable. For
 510      * now, just send one
 511      */
 512     for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
 513         unsigned char *encodedPoint = NULL;
 514         unsigned int curve_id = 0;
 515         EVP_PKEY *key_share_key = NULL;
 516         size_t encodedlen;
 517
 518         if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
 519             continue;
 520
 521         if (s->s3->tmp.pkey != NULL) {
 522             /* Shouldn't happen! */
 523             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 524             return 0;
 525         }
 526
 527         /* Generate a key for this key_share */
 528         curve_id = (pcurves[0] << 8) | pcurves[1];
 529         key_share_key = ssl_generate_pkey_curve(curve_id);
 530         if (key_share_key == NULL) {
 531             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_EVP_LIB);
 532             return 0;
 533         }
 534
 535         /* Encode the public key. */
 536         encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
 537                                                     &encodedPoint);
 538         if (encodedlen == 0) {
 539             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_EC_LIB);
 540             EVP_PKEY_free(key_share_key);
 541             return 0;
 542         }
 543
 544         /* Create KeyShareEntry */
 545         if (!WPACKET_put_bytes_u16(pkt, curve_id)
 546                 || !WPACKET_sub_memcpy_u16(pkt, encodedPoint, encodedlen)) {
 547             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 548             EVP_PKEY_free(key_share_key);
 549             OPENSSL_free(encodedPoint);
 550             return 0;
 551         }
 552
 553         /*
 554          * TODO(TLS1.3): When changing to send more than one key_share we're
 555          * going to need to be able to save more than one EVP_PKEY. For now
 556          * we reuse the existing tmp.pkey
 557          */
 558         s->s3->group_id = curve_id;
 559         s->s3->tmp.pkey = key_share_key;
 560         sharessent++;
 561         OPENSSL_free(encodedPoint);
 562     }
 563
 564     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 565         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 566         return 0;
 567     }
 568
 569     return 1;
 570 }
 571
 572 int tls_construct_client_padding(SSL *s, WPACKET *pkt, int *al)
 573 {
 574     unsigned char *padbytes;
 575     size_t hlen;
 576
 577     if ((s->options & SSL_OP_TLSEXT_PADDING) == 0)
 578         return 1;
 579
 580     /*
 581      * Add padding to workaround bugs in F5 terminators. See
 582      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
 583      * code works out the length of all existing extensions it MUST always
 584      * appear last.
 585      */
 586     if (!WPACKET_get_total_written(pkt, &hlen)) {
 587         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_PADDING, ERR_R_INTERNAL_ERROR);
 588         return 0;
 589     }
 590
 591     if (hlen > 0xff && hlen < 0x200) {
 592         hlen = 0x200 - hlen;
 593         if (hlen >= 4)
 594             hlen -= 4;
 595         else
 596             hlen = 0;
 597
 598         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
 599                 || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
 600             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_PADDING, ERR_R_INTERNAL_ERROR);
 601             return 0;
 602         }
 603         memset(padbytes, 0, hlen);
 604     }
 605
 606     return 1;
 607 }
 608
 609 /*
 610  * Parse the server's renegotiation binding and abort if it's not right
 611  */
 612 int tls_parse_server_renegotiate(SSL *s, PACKET *pkt, int *al)
 613 {
 614     size_t expected_len = s->s3->previous_client_finished_len
 615         + s->s3->previous_server_finished_len;
 616     size_t ilen;
 617     const unsigned char *data;
 618
 619     /* Check for logic errors */
 620     assert(expected_len == 0 || s->s3->previous_client_finished_len != 0);
 621     assert(expected_len == 0 || s->s3->previous_server_finished_len != 0);
 622
 623     /* Parse the length byte */
 624     if (!PACKET_get_1_len(pkt, &ilen)) {
 625         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
 626                SSL_R_RENEGOTIATION_ENCODING_ERR);
 627         *al = SSL_AD_ILLEGAL_PARAMETER;
 628         return 0;
 629     }
 630
 631     /* Consistency check */
 632     if (PACKET_remaining(pkt) != ilen) {
 633         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
 634                SSL_R_RENEGOTIATION_ENCODING_ERR);
 635         *al = SSL_AD_ILLEGAL_PARAMETER;
 636         return 0;
 637     }
 638
 639     /* Check that the extension matches */
 640     if (ilen != expected_len) {
 641         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
 642                SSL_R_RENEGOTIATION_MISMATCH);
 643         *al = SSL_AD_HANDSHAKE_FAILURE;
 644         return 0;
 645     }
 646
 647     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_client_finished_len)
 648         || memcmp(data, s->s3->previous_client_finished,
 649                   s->s3->previous_client_finished_len) != 0) {
 650         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
 651                SSL_R_RENEGOTIATION_MISMATCH);
 652         *al = SSL_AD_HANDSHAKE_FAILURE;
 653         return 0;
 654     }
 655
 656     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_server_finished_len)
 657         || memcmp(data, s->s3->previous_server_finished,
 658                   s->s3->previous_server_finished_len) != 0) {
 659         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
 660                SSL_R_RENEGOTIATION_MISMATCH);
 661         *al = SSL_AD_ILLEGAL_PARAMETER;
 662         return 0;
 663     }
 664     s->s3->send_connection_binding = 1;
 665
 666     return 1;
 667 }
 668
 669 int tls_parse_server_server_name(SSL *s, PACKET *pkt, int *al)
 670 {
 671     if (s->tlsext_hostname == NULL || PACKET_remaining(pkt) > 0) {
 672         *al = SSL_AD_UNRECOGNIZED_NAME;
 673         return 0;
 674     }
 675
 676     if (!s->hit) {
 677         if (s->session->tlsext_hostname != NULL) {
 678             *al = SSL_AD_INTERNAL_ERROR;
 679             return 0;
 680         }
 681         s->session->tlsext_hostname = OPENSSL_strdup(s->tlsext_hostname);
 682         if (s->session->tlsext_hostname == NULL) {
 683             *al = SSL_AD_INTERNAL_ERROR;
 684             return 0;
 685         }
 686     }
 687
 688     return 1;
 689 }
 690
 691 #ifndef OPENSSL_NO_EC
 692 int tls_parse_server_ec_pt_formats(SSL *s, PACKET *pkt, int *al)
 693 {
 694     unsigned int ecpointformatlist_length;
 695     PACKET ecptformatlist;
 696
 697     if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) {
 698         *al = SSL_AD_DECODE_ERROR;
 699         return 0;
 700     }
 701     if (!s->hit) {
 702         ecpointformatlist_length = PACKET_remaining(&ecptformatlist);
 703         s->session->tlsext_ecpointformatlist_length = 0;
 704
 705         OPENSSL_free(s->session->tlsext_ecpointformatlist);
 706         s->session->tlsext_ecpointformatlist =
 707              OPENSSL_malloc(ecpointformatlist_length);
 708         if (s->session->tlsext_ecpointformatlist == NULL) {
 709             *al = SSL_AD_INTERNAL_ERROR;
 710             return 0;
 711         }
 712
 713         s->session->tlsext_ecpointformatlist_length = ecpointformatlist_length;
 714
 715         if (!PACKET_copy_bytes(&ecptformatlist,
 716                                s->session->tlsext_ecpointformatlist,
 717                                ecpointformatlist_length)) {
 718             *al = SSL_AD_INTERNAL_ERROR;
 719             return 0;
 720         }
 721     }
 722
 723     return 1;
 724 }
 725 #endif
 726
 727 int tls_parse_server_session_ticket(SSL *s, PACKET *pkt, int *al)
 728 {
 729     if (s->tls_session_ticket_ext_cb &&
 730         !s->tls_session_ticket_ext_cb(s, PACKET_data(pkt),
 731                                       PACKET_remaining(pkt),
 732                                       s->tls_session_ticket_ext_cb_arg)) {
 733         *al = SSL_AD_INTERNAL_ERROR;
 734         return 0;
 735     }
 736     if (!tls_use_ticket(s) || PACKET_remaining(pkt) > 0) {
 737         *al = SSL_AD_UNSUPPORTED_EXTENSION;
 738         return 0;
 739     }
 740     s->tlsext_ticket_expected = 1;
 741
 742     return 1;
 743 }
 744
 745 #ifndef OPENSSL_NO_OCSP
 746 int tls_parse_server_status_request(SSL *s, PACKET *pkt, int *al)
 747 {
 748     /*
 749      * MUST be empty and only sent if we've requested a status
 750      * request message.
 751      */
 752     if (s->tlsext_status_type == -1 || PACKET_remaining(pkt) > 0) {
 753         *al = SSL_AD_UNSUPPORTED_EXTENSION;
 754         return 0;
 755     }
 756     /* Set flag to expect CertificateStatus message */
 757     s->tlsext_status_expected = 1;
 758
 759     return 1;
 760 }
 761 #endif
 762
 763
 764 #ifndef OPENSSL_NO_CT
 765 int tls_parse_server_sct(SSL *s, PACKET *pkt, int *al)
 766 {
 767     /*
 768      * Only take it if we asked for it - i.e if there is no CT validation
 769      * callback set, then a custom extension MAY be processing it, so we
 770      * need to let control continue to flow to that.
 771      */
 772     if (s->ct_validation_callback != NULL) {
 773         size_t size = PACKET_remaining(pkt);
 774
 775         /* Simply copy it off for later processing */
 776         if (s->tlsext_scts != NULL) {
 777             OPENSSL_free(s->tlsext_scts);
 778             s->tlsext_scts = NULL;
 779         }
 780         s->tlsext_scts_len = size;
 781         if (size > 0) {
 782             s->tlsext_scts = OPENSSL_malloc(size);
 783             if (s->tlsext_scts == NULL
 784                     || !PACKET_copy_bytes(pkt, s->tlsext_scts, size)) {
 785                 *al = SSL_AD_INTERNAL_ERROR;
 786                 return 0;
 787             }
 788         }
 789     } else {
 790         if (custom_ext_parse(s, 0, TLSEXT_TYPE_signed_certificate_timestamp,
 791                              PACKET_data(pkt), PACKET_remaining(pkt), al) <= 0)
 792             return 0;
 793     }
 794
 795     return 1;
 796 }
 797 #endif
 798
 799
 800 #ifndef OPENSSL_NO_NEXTPROTONEG
 801 /*
 802  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
 803  * elements of zero length are allowed and the set of elements must exactly
 804  * fill the length of the block. Returns 1 on success or 0 on failure.
 805  */
 806 static int ssl_next_proto_validate(PACKET *pkt)
 807 {
 808     PACKET tmp_protocol;
 809
 810     while (PACKET_remaining(pkt)) {
 811         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
 812             || PACKET_remaining(&tmp_protocol) == 0)
 813             return 0;
 814     }
 815
 816     return 1;
 817 }
 818
 819 int tls_parse_server_npn(SSL *s, PACKET *pkt, int *al)
 820 {
 821     unsigned char *selected;
 822     unsigned char selected_len;
 823     PACKET tmppkt;
 824
 825     if (s->s3->tmp.finish_md_len != 0)
 826         return 1;
 827
 828     /* We must have requested it. */
 829     if (s->ctx->next_proto_select_cb == NULL) {
 830         *al = SSL_AD_UNSUPPORTED_EXTENSION;
 831         return 0;
 832     }
 833     /* The data must be valid */
 834     tmppkt = *pkt;
 835     if (!ssl_next_proto_validate(&tmppkt)) {
 836         *al = SSL_AD_DECODE_ERROR;
 837         return 0;
 838     }
 839     if (s->ctx->next_proto_select_cb(s, &selected, &selected_len,
 840                                      PACKET_data(pkt),
 841                                      PACKET_remaining(pkt),
 842                                      s->ctx->next_proto_select_cb_arg) !=
 843              SSL_TLSEXT_ERR_OK) {
 844         *al = SSL_AD_INTERNAL_ERROR;
 845         return 0;
 846     }
 847     /*
 848      * Could be non-NULL if server has sent multiple NPN extensions in
 849      * a single Serverhello
 850      */
 851     OPENSSL_free(s->next_proto_negotiated);
 852     s->next_proto_negotiated = OPENSSL_malloc(selected_len);
 853     if (s->next_proto_negotiated == NULL) {
 854         *al = SSL_AD_INTERNAL_ERROR;
 855         return 0;
 856     }
 857
 858     memcpy(s->next_proto_negotiated, selected, selected_len);
 859     s->next_proto_negotiated_len = selected_len;
 860     s->s3->next_proto_neg_seen = 1;
 861
 862     return 1;
 863 }
 864 #endif
 865
 866 int tls_parse_server_alpn(SSL *s, PACKET *pkt, int *al)
 867 {
 868     size_t len;
 869
 870     /* We must have requested it. */
 871     if (!s->s3->alpn_sent) {
 872         *al = SSL_AD_UNSUPPORTED_EXTENSION;
 873         return 0;
 874     }
 875     /*-
 876      * The extension data consists of:
 877      *   uint16 list_length
 878      *   uint8 proto_length;
 879      *   uint8 proto[proto_length];
 880      */
 881     if (!PACKET_get_net_2_len(pkt, &len)
 882         || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len)
 883         || PACKET_remaining(pkt) != len) {
 884         *al = SSL_AD_DECODE_ERROR;
 885         return 0;
 886     }
 887     OPENSSL_free(s->s3->alpn_selected);
 888     s->s3->alpn_selected = OPENSSL_malloc(len);
 889     if (s->s3->alpn_selected == NULL) {
 890         *al = SSL_AD_INTERNAL_ERROR;
 891         return 0;
 892     }
 893     if (!PACKET_copy_bytes(pkt, s->s3->alpn_selected, len)) {
 894         *al = SSL_AD_DECODE_ERROR;
 895         return 0;
 896     }
 897     s->s3->alpn_selected_len = len;
 898
 899     return 1;
 900 }
 901
 902 #ifndef OPENSSL_NO_SRTP
 903 int tls_parse_server_use_srtp(SSL *s, PACKET *pkt, int *al)
 904 {
 905     unsigned int id, ct, mki;
 906     int i;
 907     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
 908     SRTP_PROTECTION_PROFILE *prof;
 909
 910     if (!PACKET_get_net_2(pkt, &ct)
 911         || ct != 2 || !PACKET_get_net_2(pkt, &id)
 912         || !PACKET_get_1(pkt, &mki)
 913         || PACKET_remaining(pkt) != 0) {
 914         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP,
 915                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
 916         *al = SSL_AD_DECODE_ERROR;
 917         return 0;
 918     }
 919
 920     if (mki != 0) {
 921         /* Must be no MKI, since we never offer one */
 922         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
 923         *al = SSL_AD_ILLEGAL_PARAMETER;
 924         return 0;
 925     }
 926
 927     clnt = SSL_get_srtp_profiles(s);
 928
 929     /* Throw an error if the server gave us an unsolicited extension */
 930     if (clnt == NULL) {
 931         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP, SSL_R_NO_SRTP_PROFILES);
 932         *al = SSL_AD_DECODE_ERROR;
 933         return 0;
 934     }
 935
 936     /*
 937      * Check to see if the server gave us something we support (and
 938      * presumably offered)
 939      */
 940     for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) {
 941         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
 942
 943         if (prof->id == id) {
 944             s->srtp_profile = prof;
 945             *al = 0;
 946             return 1;
 947         }
 948     }
 949
 950     SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP,
 951            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
 952     *al = SSL_AD_DECODE_ERROR;
 953     return 0;
 954 }
 955 #endif
 956
 957 int tls_parse_server_etm(SSL *s, PACKET *pkt, int *al)
 958 {
 959     /* Ignore if inappropriate ciphersuite */
 960     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
 961             && s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
 962             && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
 963         s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
 964
 965     return 1;
 966 }
 967
 968 int tls_parse_server_ems(SSL *s, PACKET *pkt, int *al)
 969 {
 970     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
 971     if (!s->hit)
 972         s->session->flags |= SSL_SESS_FLAG_EXTMS;
 973
 974     return 1;
 975 }
 976
 977 int tls_parse_server_key_share(SSL *s, PACKET *pkt, int *al)
 978 {
 979     unsigned int group_id;
 980     PACKET encoded_pt;
 981     EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
 982
 983     /* Sanity check */
 984     if (ckey == NULL) {
 985         *al = SSL_AD_INTERNAL_ERROR;
 986         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 987         return 0;
 988     }
 989
 990     if (!PACKET_get_net_2(pkt, &group_id)) {
 991         *al = SSL_AD_HANDSHAKE_FAILURE;
 992         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
 993         return 0;
 994     }
 995
 996     if (group_id != s->s3->group_id) {
 997         /*
 998          * This isn't for the group that we sent in the original
 999          * key_share!
1000          */
1001         *al = SSL_AD_HANDSHAKE_FAILURE;
1002         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1003         return 0;
1004     }
1005
1006     if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt)
1007             || PACKET_remaining(&encoded_pt) == 0) {
1008         *al = SSL_AD_DECODE_ERROR;
1009         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1010         return 0;
1011     }
1012
1013     skey = ssl_generate_pkey(ckey);
1014     if (skey == NULL) {
1015         *al = SSL_AD_INTERNAL_ERROR;
1016         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_MALLOC_FAILURE);
1017         return 0;
1018     }
1019     if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
1020                                         PACKET_remaining(&encoded_pt))) {
1021         *al = SSL_AD_DECODE_ERROR;
1022         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_BAD_ECPOINT);
1023         return 0;
1024     }
1025
1026     if (ssl_derive(s, ckey, skey, 1) == 0) {
1027         *al = SSL_AD_INTERNAL_ERROR;
1028         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1029         EVP_PKEY_free(skey);
1030         return 0;
1031     }
1032     EVP_PKEY_free(skey);
1033
1034     return 1;
1035 }
1036
1037 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
1038 {
1039     RAW_EXTENSION *extensions = NULL;
1040     PACKET extpkt;
1041
1042 #ifndef OPENSSL_NO_NEXTPROTONEG
1043     s->s3->next_proto_neg_seen = 0;
1044 #endif
1045     s->tlsext_ticket_expected = 0;
1046
1047     OPENSSL_free(s->s3->alpn_selected);
1048     s->s3->alpn_selected = NULL;
1049
1050     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1051
1052     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1053
1054     if (!PACKET_as_length_prefixed_2(pkt, &extpkt)) {
1055         /* Extensions block may be completely absent in SSLv3 */
1056         if (s->version != SSL3_VERSION || PACKET_remaining(pkt) != 0) {
1057             *al = SSL_AD_DECODE_ERROR;
1058             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_BAD_LENGTH);
1059             return 0;
1060         }
1061         PACKET_null_init(&extpkt);
1062     }
1063
1064     /*
1065      * TODO(TLS1.3): We give multiple contexts for now until we're ready to
1066      * give something more specific
1067      */
1068
1069     if (!tls_collect_extensions(s, &extpkt, EXT_TLS1_2_SERVER_HELLO
1070                                             | EXT_TLS1_3_SERVER_HELLO
1071                                             | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1072                                             | EXT_TLS1_3_CERTIFICATE,
1073                                 &extensions, al))
1074         return 0;
1075
1076     /*
1077      * Determine if we need to see RI. Strictly speaking if we want to avoid
1078      * an attack we should *always* see RI even on initial server hello
1079      * because the client doesn't see any renegotiation during an attack.
1080      * However this would mean we could not connect to any server which
1081      * doesn't support RI so for the immediate future tolerate RI absence
1082      */
1083     if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
1084             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
1085             && !extensions[TLSEXT_IDX_renegotiate].present) {
1086         *al = SSL_AD_HANDSHAKE_FAILURE;
1087         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
1088                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
1089         return 0;
1090     }
1091
1092     if (!tls_parse_all_extensions(s, EXT_TLS1_2_SERVER_HELLO
1093                                      | EXT_TLS1_3_SERVER_HELLO
1094                                      | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1095                                      | EXT_TLS1_3_CERTIFICATE,
1096                                   extensions,al))
1097         return 0;
1098
1099     if (s->hit) {
1100         /*
1101          * Check extended master secret extension is consistent with
1102          * original session.
1103          */
1104         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1105             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1106             *al = SSL_AD_HANDSHAKE_FAILURE;
1107             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
1108             return 0;
1109         }
1110     }
1111
1112     return 1;
1113 }
1114
1115 static int ssl_check_serverhello_tlsext(SSL *s)
1116 {
1117     int ret = SSL_TLSEXT_ERR_NOACK;
1118     int al = SSL_AD_UNRECOGNIZED_NAME;
1119
1120 #ifndef OPENSSL_NO_EC
1121     /*
1122      * If we are client and using an elliptic curve cryptography cipher
1123      * suite, then if server returns an EC point formats lists extension it
1124      * must contain uncompressed.
1125      */
1126     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1127     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1128     if ((s->tlsext_ecpointformatlist != NULL)
1129         && (s->tlsext_ecpointformatlist_length > 0)
1130         && (s->session->tlsext_ecpointformatlist != NULL)
1131         && (s->session->tlsext_ecpointformatlist_length > 0)
1132         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
1133         /* we are using an ECC cipher */
1134         size_t i;
1135         unsigned char *list;
1136         int found_uncompressed = 0;
1137         list = s->session->tlsext_ecpointformatlist;
1138         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
1139             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
1140                 found_uncompressed = 1;
1141                 break;
1142             }
1143         }
1144         if (!found_uncompressed) {
1145             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
1146                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1147             return -1;
1148         }
1149     }
1150     ret = SSL_TLSEXT_ERR_OK;
1151 #endif                          /* OPENSSL_NO_EC */
1152
1153     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
1154         ret =
1155             s->ctx->tlsext_servername_callback(s, &al,
1156                                                s->ctx->tlsext_servername_arg);
1157     else if (s->initial_ctx != NULL
1158              && s->initial_ctx->tlsext_servername_callback != 0)
1159         ret =
1160             s->initial_ctx->tlsext_servername_callback(s, &al,
1161                                                        s->
1162                                                        initial_ctx->tlsext_servername_arg);
1163
1164     /*
1165      * Ensure we get sensible values passed to tlsext_status_cb in the event
1166      * that we don't receive a status message
1167      */
1168     OPENSSL_free(s->tlsext_ocsp_resp);
1169     s->tlsext_ocsp_resp = NULL;
1170     s->tlsext_ocsp_resplen = 0;
1171
1172     switch (ret) {
1173     case SSL_TLSEXT_ERR_ALERT_FATAL:
1174         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1175         return -1;
1176
1177     case SSL_TLSEXT_ERR_ALERT_WARNING:
1178         ssl3_send_alert(s, SSL3_AL_WARNING, al);
1179         return 1;
1180
1181     case SSL_TLSEXT_ERR_NOACK:
1182         s->servername_done = 0;
1183     default:
1184         return 1;
1185     }
1186 }
1187
1188 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
1189 {
1190     int al = -1;
1191     if (s->version < SSL3_VERSION)
1192         return 1;
1193     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
1194         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1195         return 0;
1196     }
1197
1198     if (ssl_check_serverhello_tlsext(s) <= 0) {
1199         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
1200         return 0;
1201     }
1202     return 1;
1203 }