ssl/statem/extensions_clnt.c

   1 /*
   2  * Copyright 2016-2017 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 <openssl/ocsp.h>
  11 #include "../ssl_locl.h"
  12 #include "statem_locl.h"
  13
  14 EXT_RETURN tls_construct_ctos_renegotiate(SSL *s, WPACKET *pkt,
  15                                           unsigned int context, X509 *x,
  16                                           size_t chainidx, int *al)
  17 {
  18     /* Add RI if renegotiating */
  19     if (!s->renegotiate)
  20         return EXT_RETURN_NOT_SENT;
  21
  22     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
  23             || !WPACKET_start_sub_packet_u16(pkt)
  24             || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
  25                                s->s3->previous_client_finished_len)
  26             || !WPACKET_close(pkt)) {
  27         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
  28         return EXT_RETURN_FAIL;
  29     }
  30
  31     return EXT_RETURN_SENT;
  32 }
  33
  34 EXT_RETURN tls_construct_ctos_server_name(SSL *s, WPACKET *pkt,
  35                                           unsigned int context, X509 *x,
  36                                           size_t chainidx, int *al)
  37 {
  38     if (s->ext.hostname == NULL)
  39         return EXT_RETURN_NOT_SENT;
  40
  41     /* Add TLS extension servername to the Client Hello message */
  42     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
  43                /* Sub-packet for server_name extension */
  44             || !WPACKET_start_sub_packet_u16(pkt)
  45                /* Sub-packet for servername list (always 1 hostname)*/
  46             || !WPACKET_start_sub_packet_u16(pkt)
  47             || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
  48             || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname,
  49                                        strlen(s->ext.hostname))
  50             || !WPACKET_close(pkt)
  51             || !WPACKET_close(pkt)) {
  52         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME, ERR_R_INTERNAL_ERROR);
  53         return EXT_RETURN_FAIL;
  54     }
  55
  56     return EXT_RETURN_SENT;
  57 }
  58
  59 #ifndef OPENSSL_NO_SRP
  60 EXT_RETURN tls_construct_ctos_srp(SSL *s, WPACKET *pkt, unsigned int context,
  61                                   X509 *x, size_t chainidx, int *al)
  62 {
  63     /* Add SRP username if there is one */
  64     if (s->srp_ctx.login == NULL)
  65         return EXT_RETURN_NOT_SENT;
  66
  67     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
  68                /* Sub-packet for SRP extension */
  69             || !WPACKET_start_sub_packet_u16(pkt)
  70             || !WPACKET_start_sub_packet_u8(pkt)
  71                /* login must not be zero...internal error if so */
  72             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
  73             || !WPACKET_memcpy(pkt, s->srp_ctx.login,
  74                                strlen(s->srp_ctx.login))
  75             || !WPACKET_close(pkt)
  76             || !WPACKET_close(pkt)) {
  77         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SRP, ERR_R_INTERNAL_ERROR);
  78         return EXT_RETURN_FAIL;
  79     }
  80
  81     return EXT_RETURN_SENT;
  82 }
  83 #endif
  84
  85 #ifndef OPENSSL_NO_EC
  86 static int use_ecc(SSL *s)
  87 {
  88     int i, end;
  89     unsigned long alg_k, alg_a;
  90     STACK_OF(SSL_CIPHER) *cipher_stack = NULL;
  91
  92     /* See if we support any ECC ciphersuites */
  93     if (s->version == SSL3_VERSION)
  94         return 0;
  95
  96     cipher_stack = SSL_get_ciphers(s);
  97     end = sk_SSL_CIPHER_num(cipher_stack);
  98     for (i = 0; i < end; i++) {
  99         const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
 100
 101         alg_k = c->algorithm_mkey;
 102         alg_a = c->algorithm_auth;
 103         if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
 104                 || (alg_a & SSL_aECDSA)
 105                 || c->min_tls >= TLS1_3_VERSION)
 106             return 1;
 107     }
 108
 109     return 0;
 110 }
 111
 112 EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL *s, WPACKET *pkt,
 113                                             unsigned int context, X509 *x,
 114                                             size_t chainidx, int *al)
 115 {
 116     const unsigned char *pformats;
 117     size_t num_formats;
 118
 119     if (!use_ecc(s))
 120         return EXT_RETURN_NOT_SENT;
 121
 122     /* Add TLS extension ECPointFormats to the ClientHello message */
 123     tls1_get_formatlist(s, &pformats, &num_formats);
 124
 125     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
 126                /* Sub-packet for formats extension */
 127             || !WPACKET_start_sub_packet_u16(pkt)
 128             || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
 129             || !WPACKET_close(pkt)) {
 130         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
 131         return EXT_RETURN_FAIL;
 132     }
 133
 134     return EXT_RETURN_SENT;
 135 }
 136
 137 EXT_RETURN tls_construct_ctos_supported_groups(SSL *s, WPACKET *pkt,
 138                                                unsigned int context, X509 *x,
 139                                                size_t chainidx, int *al)
 140 {
 141     const unsigned char *pcurves = NULL, *pcurvestmp;
 142     size_t num_curves = 0, i;
 143
 144     if (!use_ecc(s))
 145         return EXT_RETURN_NOT_SENT;
 146
 147     /*
 148      * Add TLS extension supported_groups to the ClientHello message
 149      */
 150     /* TODO(TLS1.3): Add support for DHE groups */
 151     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
 152         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
 153                ERR_R_INTERNAL_ERROR);
 154         return EXT_RETURN_FAIL;
 155     }
 156     pcurvestmp = pcurves;
 157
 158     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
 159                /* Sub-packet for supported_groups extension */
 160             || !WPACKET_start_sub_packet_u16(pkt)
 161             || !WPACKET_start_sub_packet_u16(pkt)) {
 162         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
 163                ERR_R_INTERNAL_ERROR);
 164         return EXT_RETURN_FAIL;
 165     }
 166     /* Copy curve ID if supported */
 167     for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
 168         if (tls_curve_allowed(s, pcurvestmp, SSL_SECOP_CURVE_SUPPORTED)) {
 169             if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
 170                 || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
 171                     SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
 172                            ERR_R_INTERNAL_ERROR);
 173                     return EXT_RETURN_FAIL;
 174                 }
 175         }
 176     }
 177     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 178         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
 179                ERR_R_INTERNAL_ERROR);
 180         return EXT_RETURN_FAIL;
 181     }
 182
 183     return EXT_RETURN_SENT;
 184 }
 185 #endif
 186
 187 EXT_RETURN tls_construct_ctos_session_ticket(SSL *s, WPACKET *pkt,
 188                                              unsigned int context, X509 *x,
 189                                              size_t chainidx, int *al)
 190 {
 191     size_t ticklen;
 192
 193     if (!tls_use_ticket(s))
 194         return EXT_RETURN_NOT_SENT;
 195
 196     if (!s->new_session && s->session != NULL
 197             && s->session->ext.tick != NULL
 198             && s->session->ssl_version != TLS1_3_VERSION) {
 199         ticklen = s->session->ext.ticklen;
 200     } else if (s->session && s->ext.session_ticket != NULL
 201                && s->ext.session_ticket->data != NULL) {
 202         ticklen = s->ext.session_ticket->length;
 203         s->session->ext.tick = OPENSSL_malloc(ticklen);
 204         if (s->session->ext.tick == NULL) {
 205             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET,
 206                    ERR_R_INTERNAL_ERROR);
 207             return EXT_RETURN_FAIL;
 208         }
 209         memcpy(s->session->ext.tick,
 210                s->ext.session_ticket->data, ticklen);
 211         s->session->ext.ticklen = ticklen;
 212     } else {
 213         ticklen = 0;
 214     }
 215
 216     if (ticklen == 0 && s->ext.session_ticket != NULL &&
 217             s->ext.session_ticket->data == NULL)
 218         return EXT_RETURN_NOT_SENT;
 219
 220     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
 221             || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) {
 222         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
 223         return EXT_RETURN_FAIL;
 224     }
 225
 226     return EXT_RETURN_SENT;
 227 }
 228
 229 EXT_RETURN tls_construct_ctos_sig_algs(SSL *s, WPACKET *pkt,
 230                                        unsigned int context, X509 *x,
 231                                        size_t chainidx, int *al)
 232 {
 233     size_t salglen;
 234     const uint16_t *salg;
 235
 236     if (!SSL_CLIENT_USE_SIGALGS(s))
 237         return EXT_RETURN_NOT_SENT;
 238
 239     salglen = tls12_get_psigalgs(s, 1, &salg);
 240     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
 241                /* Sub-packet for sig-algs extension */
 242             || !WPACKET_start_sub_packet_u16(pkt)
 243                /* Sub-packet for the actual list */
 244             || !WPACKET_start_sub_packet_u16(pkt)
 245             || !tls12_copy_sigalgs(s, pkt, salg, salglen)
 246             || !WPACKET_close(pkt)
 247             || !WPACKET_close(pkt)) {
 248         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS, ERR_R_INTERNAL_ERROR);
 249         return EXT_RETURN_FAIL;
 250     }
 251
 252     return EXT_RETURN_SENT;
 253 }
 254
 255 #ifndef OPENSSL_NO_OCSP
 256 EXT_RETURN tls_construct_ctos_status_request(SSL *s, WPACKET *pkt,
 257                                              unsigned int context, X509 *x,
 258                                              size_t chainidx, int *al)
 259 {
 260     int i;
 261
 262     /* This extension isn't defined for client Certificates */
 263     if (x != NULL)
 264         return EXT_RETURN_NOT_SENT;
 265
 266     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp)
 267         return EXT_RETURN_NOT_SENT;
 268
 269     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
 270                /* Sub-packet for status request extension */
 271             || !WPACKET_start_sub_packet_u16(pkt)
 272             || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
 273                /* Sub-packet for the ids */
 274             || !WPACKET_start_sub_packet_u16(pkt)) {
 275         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 276         return EXT_RETURN_FAIL;
 277     }
 278     for (i = 0; i < sk_OCSP_RESPID_num(s->ext.ocsp.ids); i++) {
 279         unsigned char *idbytes;
 280         OCSP_RESPID *id = sk_OCSP_RESPID_value(s->ext.ocsp.ids, i);
 281         int idlen = i2d_OCSP_RESPID(id, NULL);
 282
 283         if (idlen <= 0
 284                    /* Sub-packet for an individual id */
 285                 || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
 286                 || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
 287             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
 288                    ERR_R_INTERNAL_ERROR);
 289             return EXT_RETURN_FAIL;
 290         }
 291     }
 292     if (!WPACKET_close(pkt)
 293             || !WPACKET_start_sub_packet_u16(pkt)) {
 294         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 295         return EXT_RETURN_FAIL;
 296     }
 297     if (s->ext.ocsp.exts) {
 298         unsigned char *extbytes;
 299         int extlen = i2d_X509_EXTENSIONS(s->ext.ocsp.exts, NULL);
 300
 301         if (extlen < 0) {
 302             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
 303                    ERR_R_INTERNAL_ERROR);
 304             return EXT_RETURN_FAIL;
 305         }
 306         if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
 307                 || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes)
 308                    != extlen) {
 309             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
 310                    ERR_R_INTERNAL_ERROR);
 311             return EXT_RETURN_FAIL;
 312        }
 313     }
 314     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 315         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
 316         return EXT_RETURN_FAIL;
 317     }
 318
 319     return EXT_RETURN_SENT;
 320 }
 321 #endif
 322
 323 #ifndef OPENSSL_NO_NEXTPROTONEG
 324 EXT_RETURN tls_construct_ctos_npn(SSL *s, WPACKET *pkt, unsigned int context,
 325                                   X509 *x, size_t chainidx, int *al)
 326 {
 327     if (s->ctx->ext.npn_select_cb == NULL || !SSL_IS_FIRST_HANDSHAKE(s))
 328         return EXT_RETURN_NOT_SENT;
 329
 330     /*
 331      * The client advertises an empty extension to indicate its support
 332      * for Next Protocol Negotiation
 333      */
 334     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
 335             || !WPACKET_put_bytes_u16(pkt, 0)) {
 336         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_NPN, ERR_R_INTERNAL_ERROR);
 337         return EXT_RETURN_FAIL;
 338     }
 339
 340     return EXT_RETURN_SENT;
 341 }
 342 #endif
 343
 344 EXT_RETURN tls_construct_ctos_alpn(SSL *s, WPACKET *pkt, unsigned int context,
 345                                    X509 *x, size_t chainidx, int *al)
 346 {
 347     s->s3->alpn_sent = 0;
 348
 349     if (s->ext.alpn == NULL || !SSL_IS_FIRST_HANDSHAKE(s))
 350         return EXT_RETURN_NOT_SENT;
 351
 352     if (!WPACKET_put_bytes_u16(pkt,
 353                 TLSEXT_TYPE_application_layer_protocol_negotiation)
 354                /* Sub-packet ALPN extension */
 355             || !WPACKET_start_sub_packet_u16(pkt)
 356             || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len)
 357             || !WPACKET_close(pkt)) {
 358         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_ALPN, ERR_R_INTERNAL_ERROR);
 359         return EXT_RETURN_FAIL;
 360     }
 361     s->s3->alpn_sent = 1;
 362
 363     return EXT_RETURN_SENT;
 364 }
 365
 366
 367 #ifndef OPENSSL_NO_SRTP
 368 EXT_RETURN tls_construct_ctos_use_srtp(SSL *s, WPACKET *pkt,
 369                                        unsigned int context, X509 *x,
 370                                        size_t chainidx, int *al)
 371 {
 372     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
 373     int i, end;
 374
 375     if (clnt == NULL)
 376         return EXT_RETURN_NOT_SENT;
 377
 378     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
 379                /* Sub-packet for SRTP extension */
 380             || !WPACKET_start_sub_packet_u16(pkt)
 381                /* Sub-packet for the protection profile list */
 382             || !WPACKET_start_sub_packet_u16(pkt)) {
 383         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP, ERR_R_INTERNAL_ERROR);
 384         return EXT_RETURN_FAIL;
 385     }
 386
 387     end = sk_SRTP_PROTECTION_PROFILE_num(clnt);
 388     for (i = 0; i < end; i++) {
 389         const SRTP_PROTECTION_PROFILE *prof =
 390             sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
 391
 392         if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
 393             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP, ERR_R_INTERNAL_ERROR);
 394             return EXT_RETURN_FAIL;
 395         }
 396     }
 397     if (!WPACKET_close(pkt)
 398                /* Add an empty use_mki value */
 399             || !WPACKET_put_bytes_u8(pkt, 0)
 400             || !WPACKET_close(pkt)) {
 401         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP, ERR_R_INTERNAL_ERROR);
 402         return EXT_RETURN_FAIL;
 403     }
 404
 405     return EXT_RETURN_SENT;
 406 }
 407 #endif
 408
 409 EXT_RETURN tls_construct_ctos_etm(SSL *s, WPACKET *pkt, unsigned int context,
 410                                   X509 *x, size_t chainidx, int *al)
 411 {
 412     if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
 413         return EXT_RETURN_NOT_SENT;
 414
 415     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
 416             || !WPACKET_put_bytes_u16(pkt, 0)) {
 417         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_ETM, ERR_R_INTERNAL_ERROR);
 418         return EXT_RETURN_FAIL;
 419     }
 420
 421     return EXT_RETURN_SENT;
 422 }
 423
 424 #ifndef OPENSSL_NO_CT
 425 EXT_RETURN tls_construct_ctos_sct(SSL *s, WPACKET *pkt, unsigned int context,
 426                                   X509 *x, size_t chainidx, int *al)
 427 {
 428     if (s->ct_validation_callback == NULL)
 429         return EXT_RETURN_NOT_SENT;
 430
 431     /* Not defined for client Certificates */
 432     if (x != NULL)
 433         return EXT_RETURN_NOT_SENT;
 434
 435     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
 436             || !WPACKET_put_bytes_u16(pkt, 0)) {
 437         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SCT, ERR_R_INTERNAL_ERROR);
 438         return EXT_RETURN_FAIL;
 439     }
 440
 441     return EXT_RETURN_SENT;
 442 }
 443 #endif
 444
 445 EXT_RETURN tls_construct_ctos_ems(SSL *s, WPACKET *pkt, unsigned int context,
 446                                   X509 *x, size_t chainidx, int *al)
 447 {
 448     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
 449             || !WPACKET_put_bytes_u16(pkt, 0)) {
 450         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_EMS, ERR_R_INTERNAL_ERROR);
 451         return EXT_RETURN_FAIL;
 452     }
 453
 454     return EXT_RETURN_SENT;
 455 }
 456
 457 EXT_RETURN tls_construct_ctos_supported_versions(SSL *s, WPACKET *pkt,
 458                                                  unsigned int context, X509 *x,
 459                                                  size_t chainidx, int *al)
 460 {
 461     int currv, min_version, max_version, reason;
 462
 463     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
 464             || !WPACKET_start_sub_packet_u16(pkt)
 465             || !WPACKET_start_sub_packet_u8(pkt)) {
 466         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
 467                ERR_R_INTERNAL_ERROR);
 468         return EXT_RETURN_FAIL;
 469     }
 470
 471     reason = ssl_get_min_max_version(s, &min_version, &max_version);
 472     if (reason != 0) {
 473         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS, reason);
 474         return EXT_RETURN_FAIL;
 475     }
 476
 477     /*
 478      * TODO(TLS1.3): There is some discussion on the TLS list as to whether
 479      * we should include versions <TLS1.2. For the moment we do. To be
 480      * reviewed later.
 481      */
 482     for (currv = max_version; currv >= min_version; currv--) {
 483         /* TODO(TLS1.3): Remove this first if clause prior to release!! */
 484         if (currv == TLS1_3_VERSION) {
 485             if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
 486                 SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
 487                        ERR_R_INTERNAL_ERROR);
 488                 return EXT_RETURN_FAIL;
 489             }
 490         } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
 491             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
 492                    ERR_R_INTERNAL_ERROR);
 493             return EXT_RETURN_FAIL;
 494         }
 495     }
 496     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 497         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
 498                ERR_R_INTERNAL_ERROR);
 499         return EXT_RETURN_FAIL;
 500     }
 501
 502     return EXT_RETURN_SENT;
 503 }
 504
 505 /*
 506  * Construct a psk_kex_modes extension.
 507  */
 508 EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL *s, WPACKET *pkt,
 509                                             unsigned int context, X509 *x,
 510                                             size_t chainidx, int *al)
 511 {
 512 #ifndef OPENSSL_NO_TLS1_3
 513     int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX;
 514
 515     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes)
 516             || !WPACKET_start_sub_packet_u16(pkt)
 517             || !WPACKET_start_sub_packet_u8(pkt)
 518             || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE)
 519             || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE))
 520             || !WPACKET_close(pkt)
 521             || !WPACKET_close(pkt)) {
 522         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES, ERR_R_INTERNAL_ERROR);
 523         return EXT_RETURN_FAIL;
 524     }
 525
 526     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE_DHE;
 527     if (nodhe)
 528         s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
 529 #endif
 530
 531     return EXT_RETURN_SENT;
 532 }
 533
 534 #ifndef OPENSSL_NO_TLS1_3
 535 static int add_key_share(SSL *s, WPACKET *pkt, unsigned int curve_id)
 536 {
 537     unsigned char *encoded_point = NULL;
 538     EVP_PKEY *key_share_key = NULL;
 539     size_t encodedlen;
 540
 541     if (s->s3->tmp.pkey != NULL) {
 542         if (!ossl_assert(s->hello_retry_request)) {
 543             SSLerr(SSL_F_ADD_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 544             return 0;
 545         }
 546         /*
 547          * Could happen if we got an HRR that wasn't requesting a new key_share
 548          */
 549         key_share_key = s->s3->tmp.pkey;
 550     } else {
 551         key_share_key = ssl_generate_pkey_curve(curve_id);
 552         if (key_share_key == NULL) {
 553             SSLerr(SSL_F_ADD_KEY_SHARE, ERR_R_EVP_LIB);
 554             return 0;
 555         }
 556     }
 557
 558     /* Encode the public key. */
 559     encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
 560                                                 &encoded_point);
 561     if (encodedlen == 0) {
 562         SSLerr(SSL_F_ADD_KEY_SHARE, ERR_R_EC_LIB);
 563         goto err;
 564     }
 565
 566     /* Create KeyShareEntry */
 567     if (!WPACKET_put_bytes_u16(pkt, curve_id)
 568             || !WPACKET_sub_memcpy_u16(pkt, encoded_point, encodedlen)) {
 569         SSLerr(SSL_F_ADD_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 570         goto err;
 571     }
 572
 573     /*
 574      * TODO(TLS1.3): When changing to send more than one key_share we're
 575      * going to need to be able to save more than one EVP_PKEY. For now
 576      * we reuse the existing tmp.pkey
 577      */
 578     s->s3->tmp.pkey = key_share_key;
 579     s->s3->group_id = curve_id;
 580     OPENSSL_free(encoded_point);
 581
 582     return 1;
 583  err:
 584     if (s->s3->tmp.pkey == NULL)
 585         EVP_PKEY_free(key_share_key);
 586     OPENSSL_free(encoded_point);
 587     return 0;
 588 }
 589 #endif
 590
 591 EXT_RETURN tls_construct_ctos_key_share(SSL *s, WPACKET *pkt,
 592                                         unsigned int context, X509 *x,
 593                                         size_t chainidx, int *al)
 594 {
 595 #ifndef OPENSSL_NO_TLS1_3
 596     size_t i, num_curves = 0;
 597     const unsigned char *pcurves = NULL;
 598     unsigned int curve_id = 0;
 599
 600     /* key_share extension */
 601     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
 602                /* Extension data sub-packet */
 603             || !WPACKET_start_sub_packet_u16(pkt)
 604                /* KeyShare list sub-packet */
 605             || !WPACKET_start_sub_packet_u16(pkt)) {
 606         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 607         return EXT_RETURN_FAIL;
 608     }
 609
 610     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
 611         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 612         return EXT_RETURN_FAIL;
 613     }
 614
 615     /*
 616      * TODO(TLS1.3): Make the number of key_shares sent configurable. For
 617      * now, just send one
 618      */
 619     if (s->s3->group_id != 0) {
 620         curve_id = s->s3->group_id;
 621     } else {
 622         for (i = 0; i < num_curves; i++, pcurves += 2) {
 623
 624             if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
 625                 continue;
 626
 627             curve_id = bytestogroup(pcurves);
 628             break;
 629         }
 630     }
 631
 632     if (curve_id == 0) {
 633         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
 634         return EXT_RETURN_FAIL;
 635     }
 636
 637     if (!add_key_share(s, pkt, curve_id))
 638         return EXT_RETURN_FAIL;
 639
 640     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
 641         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
 642         return EXT_RETURN_FAIL;
 643     }
 644 #endif
 645
 646     return EXT_RETURN_SENT;
 647 }
 648
 649 EXT_RETURN tls_construct_ctos_cookie(SSL *s, WPACKET *pkt, unsigned int context,
 650                                      X509 *x, size_t chainidx, int *al)
 651 {
 652     EXT_RETURN ret = EXT_RETURN_FAIL;
 653
 654     /* Should only be set if we've had an HRR */
 655     if (s->ext.tls13_cookie_len == 0)
 656         return EXT_RETURN_NOT_SENT;
 657
 658     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie)
 659                /* Extension data sub-packet */
 660             || !WPACKET_start_sub_packet_u16(pkt)
 661             || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie,
 662                                        s->ext.tls13_cookie_len)
 663             || !WPACKET_close(pkt)) {
 664         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_COOKIE, ERR_R_INTERNAL_ERROR);
 665         goto end;
 666     }
 667
 668     ret = EXT_RETURN_SENT;
 669  end:
 670     OPENSSL_free(s->ext.tls13_cookie);
 671     s->ext.tls13_cookie = NULL;
 672     s->ext.tls13_cookie_len = 0;
 673
 674     return ret;
 675 }
 676
 677 EXT_RETURN tls_construct_ctos_early_data(SSL *s, WPACKET *pkt,
 678                                          unsigned int context, X509 *x,
 679                                          size_t chainidx, int *al)
 680 {
 681     if (s->early_data_state != SSL_EARLY_DATA_CONNECTING
 682             || s->session->ext.max_early_data == 0) {
 683         s->max_early_data = 0;
 684         return EXT_RETURN_NOT_SENT;
 685     }
 686     s->max_early_data = s->session->ext.max_early_data;
 687
 688     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
 689             || !WPACKET_start_sub_packet_u16(pkt)
 690             || !WPACKET_close(pkt)) {
 691         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA, ERR_R_INTERNAL_ERROR);
 692         return EXT_RETURN_FAIL;
 693     }
 694
 695     /*
 696      * We set this to rejected here. Later, if the server acknowledges the
 697      * extension, we set it to accepted.
 698      */
 699     s->ext.early_data = SSL_EARLY_DATA_REJECTED;
 700
 701     return EXT_RETURN_SENT;
 702 }
 703
 704 #define F5_WORKAROUND_MIN_MSG_LEN   0xff
 705 #define F5_WORKAROUND_MAX_MSG_LEN   0x200
 706
 707 /*
 708  * PSK pre binder overhead =
 709  *  2 bytes for TLSEXT_TYPE_psk
 710  *  2 bytes for extension length
 711  *  2 bytes for identities list length
 712  *  2 bytes for identity length
 713  *  4 bytes for obfuscated_ticket_age
 714  *  2 bytes for binder list length
 715  *  1 byte for binder length
 716  * The above excludes the number of bytes for the identity itself and the
 717  * subsequent binder bytes
 718  */
 719 #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1)
 720
 721 EXT_RETURN tls_construct_ctos_padding(SSL *s, WPACKET *pkt,
 722                                       unsigned int context, X509 *x,
 723                                       size_t chainidx, int *al)
 724 {
 725     unsigned char *padbytes;
 726     size_t hlen;
 727
 728     if ((s->options & SSL_OP_TLSEXT_PADDING) == 0)
 729         return EXT_RETURN_NOT_SENT;
 730
 731     /*
 732      * Add padding to workaround bugs in F5 terminators. See RFC7685.
 733      * This code calculates the length of all extensions added so far but
 734      * excludes the PSK extension (because that MUST be written last). Therefore
 735      * this extension MUST always appear second to last.
 736      */
 737     if (!WPACKET_get_total_written(pkt, &hlen)) {
 738         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PADDING, ERR_R_INTERNAL_ERROR);
 739         return EXT_RETURN_FAIL;
 740     }
 741
 742     /*
 743      * If we're going to send a PSK then that will be written out after this
 744      * extension, so we need to calculate how long it is going to be.
 745      */
 746     if (s->session->ssl_version == TLS1_3_VERSION
 747             && s->session->ext.ticklen != 0
 748             && s->session->cipher != NULL) {
 749         const EVP_MD *md = ssl_md(s->session->cipher->algorithm2);
 750
 751         if (md != NULL) {
 752             /*
 753              * Add the fixed PSK overhead, the identity length and the binder
 754              * length.
 755              */
 756             hlen +=  PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen
 757                      + EVP_MD_size(md);
 758         }
 759     }
 760
 761     if (hlen > F5_WORKAROUND_MIN_MSG_LEN && hlen < F5_WORKAROUND_MAX_MSG_LEN) {
 762         /* Calculate the amount of padding we need to add */
 763         hlen = F5_WORKAROUND_MAX_MSG_LEN - hlen;
 764
 765         /*
 766          * Take off the size of extension header itself (2 bytes for type and
 767          * 2 bytes for length bytes)
 768          */
 769         if (hlen >= 4)
 770             hlen -= 4;
 771         else
 772             hlen = 0;
 773
 774         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
 775                 || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
 776             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PADDING, ERR_R_INTERNAL_ERROR);
 777             return 0;
 778         }
 779         memset(padbytes, 0, hlen);
 780     }
 781
 782     return EXT_RETURN_SENT;
 783 }
 784
 785 /*
 786  * Construct the pre_shared_key extension
 787  */
 788 EXT_RETURN tls_construct_ctos_psk(SSL *s, WPACKET *pkt, unsigned int context,
 789                                   X509 *x, size_t chainidx, int *al)
 790 {
 791 #ifndef OPENSSL_NO_TLS1_3
 792     uint32_t now, agesec, agems = 0;
 793     size_t reshashsize = 0, pskhashsize = 0, binderoffset, msglen, idlen = 0;
 794     unsigned char *resbinder = NULL, *pskbinder = NULL, *msgstart = NULL;
 795     const unsigned char *id = 0;
 796     const EVP_MD *handmd = NULL, *mdres = NULL, *mdpsk = NULL;
 797     EXT_RETURN ret = EXT_RETURN_FAIL;
 798     SSL_SESSION *psksess = NULL;
 799     int dores = 0;
 800
 801     s->session->ext.tick_identity = TLSEXT_PSK_BAD_IDENTITY;
 802
 803     /*
 804      * Note: At this stage of the code we only support adding a single
 805      * resumption PSK. If we add support for multiple PSKs then the length
 806      * calculations in the padding extension will need to be adjusted.
 807      */
 808
 809     /*
 810      * If this is an incompatible or new session then we have nothing to resume
 811      * so don't add this extension.
 812      */
 813     if (s->session->ssl_version != TLS1_3_VERSION
 814             || (s->session->ext.ticklen == 0 && s->psk_use_session_cb == NULL))
 815         return EXT_RETURN_NOT_SENT;
 816
 817     if (s->hello_retry_request)
 818         handmd = ssl_handshake_md(s);
 819
 820     if (s->psk_use_session_cb != NULL
 821             && !s->psk_use_session_cb(s, handmd, &id, &idlen, &psksess)) {
 822         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, SSL_R_BAD_PSK);
 823         goto err;
 824     }
 825
 826     if (s->session->ext.ticklen != 0) {
 827         /* Get the digest associated with the ciphersuite in the session */
 828         if (s->session->cipher == NULL) {
 829             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 830             goto err;
 831         }
 832         mdres = ssl_md(s->session->cipher->algorithm2);
 833         if (mdres == NULL) {
 834             /*
 835              * Don't recognize this cipher so we can't use the session.
 836              * Ignore it
 837              */
 838             goto dopsksess;
 839         }
 840
 841         if (s->hello_retry_request && mdres != handmd) {
 842             /*
 843              * Selected ciphersuite hash does not match the hash for the session
 844              * so we can't use it.
 845              */
 846             goto dopsksess;
 847         }
 848
 849         /*
 850          * Technically the C standard just says time() returns a time_t and says
 851          * nothing about the encoding of that type. In practice most
 852          * implementations follow POSIX which holds it as an integral type in
 853          * seconds since epoch. We've already made the assumption that we can do
 854          * this in multiple places in the code, so portability shouldn't be an
 855          * issue.
 856          */
 857         now = (uint32_t)time(NULL);
 858         agesec = now - (uint32_t)s->session->time;
 859
 860         if (s->session->ext.tick_lifetime_hint < agesec) {
 861             /* Ticket is too old. Ignore it. */
 862             goto dopsksess;
 863         }
 864
 865         /*
 866          * Calculate age in ms. We're just doing it to nearest second. Should be
 867          * good enough.
 868          */
 869         agems = agesec * (uint32_t)1000;
 870
 871         if (agesec != 0 && agems / (uint32_t)1000 != agesec) {
 872             /*
 873              * Overflow. Shouldn't happen unless this is a *really* old session.
 874              * If so we just ignore it.
 875              */
 876             goto dopsksess;
 877         }
 878
 879         /*
 880          * Obfuscate the age. Overflow here is fine, this addition is supposed
 881          * to be mod 2^32.
 882          */
 883         agems += s->session->ext.tick_age_add;
 884
 885         reshashsize = EVP_MD_size(mdres);
 886         dores = 1;
 887     }
 888
 889  dopsksess:
 890     if (!dores && psksess == NULL)
 891         return EXT_RETURN_NOT_SENT;
 892
 893     if (psksess != NULL) {
 894         mdpsk = ssl_md(psksess->cipher->algorithm2);
 895         if (mdpsk == NULL) {
 896             /*
 897              * Don't recognize this cipher so we can't use the session.
 898              * If this happens it's an application bug.
 899              */
 900             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, SSL_R_BAD_PSK);
 901             goto err;
 902         }
 903
 904         if (s->hello_retry_request && mdpsk != handmd) {
 905             /*
 906              * Selected ciphersuite hash does not match the hash for the PSK
 907              * session. This is an application bug.
 908              */
 909             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, SSL_R_BAD_PSK);
 910             goto err;
 911         }
 912
 913         pskhashsize = EVP_MD_size(mdpsk);
 914     }
 915
 916     /* Create the extension, but skip over the binder for now */
 917     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
 918             || !WPACKET_start_sub_packet_u16(pkt)
 919             || !WPACKET_start_sub_packet_u16(pkt)) {
 920         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 921         goto err;
 922     }
 923
 924     if (dores) {
 925         if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick,
 926                                            s->session->ext.ticklen)
 927                 || !WPACKET_put_bytes_u32(pkt, agems)) {
 928             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 929             goto err;
 930         }
 931     }
 932
 933     if (psksess != NULL) {
 934         if (!WPACKET_sub_memcpy_u16(pkt, id, idlen)
 935                 || !WPACKET_put_bytes_u32(pkt, 0)) {
 936             SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 937             goto err;
 938         }
 939     }
 940
 941     if (!WPACKET_close(pkt)
 942             || !WPACKET_get_total_written(pkt, &binderoffset)
 943             || !WPACKET_start_sub_packet_u16(pkt)
 944             || (dores
 945                 && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder))
 946             || (psksess != NULL
 947                 && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder))
 948             || !WPACKET_close(pkt)
 949             || !WPACKET_close(pkt)
 950             || !WPACKET_get_total_written(pkt, &msglen)
 951                /*
 952                 * We need to fill in all the sub-packet lengths now so we can
 953                 * calculate the HMAC of the message up to the binders
 954                 */
 955             || !WPACKET_fill_lengths(pkt)) {
 956         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 957         goto err;
 958     }
 959
 960     msgstart = WPACKET_get_curr(pkt) - msglen;
 961
 962     if (dores
 963             && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL,
 964                                  resbinder, s->session, 1, 0) != 1) {
 965         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 966         goto err;
 967     }
 968
 969     if (psksess != NULL
 970             && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL,
 971                                  pskbinder, psksess, 1, 1) != 1) {
 972         SSLerr(SSL_F_TLS_CONSTRUCT_CTOS_PSK, ERR_R_INTERNAL_ERROR);
 973         goto err;
 974     }
 975
 976     if (dores)
 977         s->session->ext.tick_identity = 0;
 978     SSL_SESSION_free(s->psksession);
 979     s->psksession = psksess;
 980     if (psksess != NULL)
 981         s->psksession->ext.tick_identity = (dores ? 1 : 0);
 982     psksess = NULL;
 983
 984     ret = EXT_RETURN_SENT;
 985  err:
 986     SSL_SESSION_free(psksess);
 987     return ret;
 988 #else
 989     return 1;
 990 #endif
 991 }
 992
 993 /*
 994  * Parse the server's renegotiation binding and abort if it's not right
 995  */
 996 int tls_parse_stoc_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
 997                                X509 *x, size_t chainidx, int *al)
 998 {
 999     size_t expected_len = s->s3->previous_client_finished_len
1000         + s->s3->previous_server_finished_len;
1001     size_t ilen;
1002     const unsigned char *data;
1003
1004     /* Check for logic errors */
1005     if (!ossl_assert(expected_len == 0
1006                      || s->s3->previous_client_finished_len != 0)
1007         || !ossl_assert(expected_len == 0
1008                         || s->s3->previous_server_finished_len != 0)) {
1009         *al = SSL_AD_INTERNAL_ERROR;
1010         return 0;
1011     }
1012
1013     /* Parse the length byte */
1014     if (!PACKET_get_1_len(pkt, &ilen)) {
1015         SSLerr(SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1016                SSL_R_RENEGOTIATION_ENCODING_ERR);
1017         *al = SSL_AD_DECODE_ERROR;
1018         return 0;
1019     }
1020
1021     /* Consistency check */
1022     if (PACKET_remaining(pkt) != ilen) {
1023         SSLerr(SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1024                SSL_R_RENEGOTIATION_ENCODING_ERR);
1025         *al = SSL_AD_DECODE_ERROR;
1026         return 0;
1027     }
1028
1029     /* Check that the extension matches */
1030     if (ilen != expected_len) {
1031         SSLerr(SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1032                SSL_R_RENEGOTIATION_MISMATCH);
1033         *al = SSL_AD_ILLEGAL_PARAMETER;
1034         return 0;
1035     }
1036
1037     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_client_finished_len)
1038         || memcmp(data, s->s3->previous_client_finished,
1039                   s->s3->previous_client_finished_len) != 0) {
1040         SSLerr(SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1041                SSL_R_RENEGOTIATION_MISMATCH);
1042         *al = SSL_AD_ILLEGAL_PARAMETER;
1043         return 0;
1044     }
1045
1046     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_server_finished_len)
1047         || memcmp(data, s->s3->previous_server_finished,
1048                   s->s3->previous_server_finished_len) != 0) {
1049         SSLerr(SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1050                SSL_R_RENEGOTIATION_MISMATCH);
1051         *al = SSL_AD_ILLEGAL_PARAMETER;
1052         return 0;
1053     }
1054     s->s3->send_connection_binding = 1;
1055
1056     return 1;
1057 }
1058
1059 int tls_parse_stoc_server_name(SSL *s, PACKET *pkt, unsigned int context,
1060                                X509 *x, size_t chainidx, int *al)
1061 {
1062     if (s->ext.hostname == NULL) {
1063         *al = SSL_AD_INTERNAL_ERROR;
1064         return 0;
1065     }
1066
1067     if (PACKET_remaining(pkt) > 0) {
1068         *al = SSL_AD_DECODE_ERROR;
1069         return 0;
1070     }
1071
1072     if (!s->hit) {
1073         if (s->session->ext.hostname != NULL) {
1074             *al = SSL_AD_INTERNAL_ERROR;
1075             return 0;
1076         }
1077         s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname);
1078         if (s->session->ext.hostname == NULL) {
1079             *al = SSL_AD_INTERNAL_ERROR;
1080             return 0;
1081         }
1082     }
1083
1084     return 1;
1085 }
1086
1087 #ifndef OPENSSL_NO_EC
1088 int tls_parse_stoc_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
1089                                  X509 *x, size_t chainidx, int *al)
1090 {
1091     unsigned int ecpointformats_len;
1092     PACKET ecptformatlist;
1093
1094     if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) {
1095         *al = SSL_AD_DECODE_ERROR;
1096         return 0;
1097     }
1098     if (!s->hit) {
1099         ecpointformats_len = PACKET_remaining(&ecptformatlist);
1100         s->session->ext.ecpointformats_len = 0;
1101
1102         OPENSSL_free(s->session->ext.ecpointformats);
1103         s->session->ext.ecpointformats = OPENSSL_malloc(ecpointformats_len);
1104         if (s->session->ext.ecpointformats == NULL) {
1105             *al = SSL_AD_INTERNAL_ERROR;
1106             return 0;
1107         }
1108
1109         s->session->ext.ecpointformats_len = ecpointformats_len;
1110
1111         if (!PACKET_copy_bytes(&ecptformatlist,
1112                                s->session->ext.ecpointformats,
1113                                ecpointformats_len)) {
1114             *al = SSL_AD_INTERNAL_ERROR;
1115             return 0;
1116         }
1117     }
1118
1119     return 1;
1120 }
1121 #endif
1122
1123 int tls_parse_stoc_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
1124                                   X509 *x, size_t chainidx, int *al)
1125 {
1126     if (s->ext.session_ticket_cb != NULL &&
1127         !s->ext.session_ticket_cb(s, PACKET_data(pkt),
1128                               PACKET_remaining(pkt),
1129                               s->ext.session_ticket_cb_arg)) {
1130         *al = SSL_AD_INTERNAL_ERROR;
1131         return 0;
1132     }
1133
1134     if (!tls_use_ticket(s)) {
1135         *al = SSL_AD_UNSUPPORTED_EXTENSION;
1136         return 0;
1137     }
1138     if (PACKET_remaining(pkt) > 0) {
1139         *al = SSL_AD_DECODE_ERROR;
1140         return 0;
1141     }
1142
1143     s->ext.ticket_expected = 1;
1144
1145     return 1;
1146 }
1147
1148 #ifndef OPENSSL_NO_OCSP
1149 int tls_parse_stoc_status_request(SSL *s, PACKET *pkt, unsigned int context,
1150                                   X509 *x, size_t chainidx, int *al)
1151 {
1152     /*
1153      * MUST only be sent if we've requested a status
1154      * request message. In TLS <= 1.2 it must also be empty.
1155      */
1156     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
1157         *al = SSL_AD_UNSUPPORTED_EXTENSION;
1158         return 0;
1159     }
1160     if (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) > 0) {
1161         *al = SSL_AD_DECODE_ERROR;
1162         return 0;
1163     }
1164
1165     if (SSL_IS_TLS13(s)) {
1166         /* We only know how to handle this if it's for the first Certificate in
1167          * the chain. We ignore any other responses.
1168          */
1169         if (chainidx != 0)
1170             return 1;
1171         return tls_process_cert_status_body(s, pkt, al);
1172     }
1173
1174     /* Set flag to expect CertificateStatus message */
1175     s->ext.status_expected = 1;
1176
1177     return 1;
1178 }
1179 #endif
1180
1181
1182 #ifndef OPENSSL_NO_CT
1183 int tls_parse_stoc_sct(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1184                        size_t chainidx, int *al)
1185 {
1186     /*
1187      * Only take it if we asked for it - i.e if there is no CT validation
1188      * callback set, then a custom extension MAY be processing it, so we
1189      * need to let control continue to flow to that.
1190      */
1191     if (s->ct_validation_callback != NULL) {
1192         size_t size = PACKET_remaining(pkt);
1193
1194         /* Simply copy it off for later processing */
1195         OPENSSL_free(s->ext.scts);
1196         s->ext.scts = NULL;
1197
1198         s->ext.scts_len = size;
1199         if (size > 0) {
1200             s->ext.scts = OPENSSL_malloc(size);
1201             if (s->ext.scts == NULL
1202                     || !PACKET_copy_bytes(pkt, s->ext.scts, size)) {
1203                 *al = SSL_AD_INTERNAL_ERROR;
1204                 return 0;
1205             }
1206         }
1207     } else {
1208         ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
1209                         ? ENDPOINT_CLIENT : ENDPOINT_BOTH;
1210
1211         /*
1212          * If we didn't ask for it then there must be a custom extension,
1213          * otherwise this is unsolicited.
1214          */
1215         if (custom_ext_find(&s->cert->custext, role,
1216                             TLSEXT_TYPE_signed_certificate_timestamp,
1217                             NULL) == NULL) {
1218             *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1219             return 0;
1220         }
1221
1222         if (custom_ext_parse(s, context,
1223                              TLSEXT_TYPE_signed_certificate_timestamp,
1224                              PACKET_data(pkt), PACKET_remaining(pkt),
1225                              x, chainidx, al) <= 0)
1226             return 0;
1227     }
1228
1229     return 1;
1230 }
1231 #endif
1232
1233
1234 #ifndef OPENSSL_NO_NEXTPROTONEG
1235 /*
1236  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
1237  * elements of zero length are allowed and the set of elements must exactly
1238  * fill the length of the block. Returns 1 on success or 0 on failure.
1239  */
1240 static int ssl_next_proto_validate(PACKET *pkt)
1241 {
1242     PACKET tmp_protocol;
1243
1244     while (PACKET_remaining(pkt)) {
1245         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
1246             || PACKET_remaining(&tmp_protocol) == 0)
1247             return 0;
1248     }
1249
1250     return 1;
1251 }
1252
1253 int tls_parse_stoc_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1254                        size_t chainidx, int *al)
1255 {
1256     unsigned char *selected;
1257     unsigned char selected_len;
1258     PACKET tmppkt;
1259
1260     /* Check if we are in a renegotiation. If so ignore this extension */
1261     if (!SSL_IS_FIRST_HANDSHAKE(s))
1262         return 1;
1263
1264     /* We must have requested it. */
1265     if (s->ctx->ext.npn_select_cb == NULL) {
1266         *al = SSL_AD_UNSUPPORTED_EXTENSION;
1267         return 0;
1268     }
1269
1270     /* The data must be valid */
1271     tmppkt = *pkt;
1272     if (!ssl_next_proto_validate(&tmppkt)) {
1273         *al = SSL_AD_DECODE_ERROR;
1274         return 0;
1275     }
1276     if (s->ctx->ext.npn_select_cb(s, &selected, &selected_len,
1277                                   PACKET_data(pkt),
1278                                   PACKET_remaining(pkt),
1279                                   s->ctx->ext.npn_select_cb_arg) !=
1280              SSL_TLSEXT_ERR_OK) {
1281         *al = SSL_AD_INTERNAL_ERROR;
1282         return 0;
1283     }
1284
1285     /*
1286      * Could be non-NULL if server has sent multiple NPN extensions in
1287      * a single Serverhello
1288      */
1289     OPENSSL_free(s->ext.npn);
1290     s->ext.npn = OPENSSL_malloc(selected_len);
1291     if (s->ext.npn == NULL) {
1292         *al = SSL_AD_INTERNAL_ERROR;
1293         return 0;
1294     }
1295
1296     memcpy(s->ext.npn, selected, selected_len);
1297     s->ext.npn_len = selected_len;
1298     s->s3->npn_seen = 1;
1299
1300     return 1;
1301 }
1302 #endif
1303
1304 int tls_parse_stoc_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1305                         size_t chainidx, int *al)
1306 {
1307     size_t len;
1308
1309     /* We must have requested it. */
1310     if (!s->s3->alpn_sent) {
1311         *al = SSL_AD_UNSUPPORTED_EXTENSION;
1312         return 0;
1313     }
1314     /*-
1315      * The extension data consists of:
1316      *   uint16 list_length
1317      *   uint8 proto_length;
1318      *   uint8 proto[proto_length];
1319      */
1320     if (!PACKET_get_net_2_len(pkt, &len)
1321         || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len)
1322         || PACKET_remaining(pkt) != len) {
1323         *al = SSL_AD_DECODE_ERROR;
1324         return 0;
1325     }
1326     OPENSSL_free(s->s3->alpn_selected);
1327     s->s3->alpn_selected = OPENSSL_malloc(len);
1328     if (s->s3->alpn_selected == NULL) {
1329         *al = SSL_AD_INTERNAL_ERROR;
1330         return 0;
1331     }
1332     if (!PACKET_copy_bytes(pkt, s->s3->alpn_selected, len)) {
1333         *al = SSL_AD_DECODE_ERROR;
1334         return 0;
1335     }
1336     s->s3->alpn_selected_len = len;
1337
1338     return 1;
1339 }
1340
1341 #ifndef OPENSSL_NO_SRTP
1342 int tls_parse_stoc_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1343                             size_t chainidx, int *al)
1344 {
1345     unsigned int id, ct, mki;
1346     int i;
1347     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
1348     SRTP_PROTECTION_PROFILE *prof;
1349
1350     if (!PACKET_get_net_2(pkt, &ct) || ct != 2
1351             || !PACKET_get_net_2(pkt, &id)
1352             || !PACKET_get_1(pkt, &mki)
1353             || PACKET_remaining(pkt) != 0) {
1354         SSLerr(SSL_F_TLS_PARSE_STOC_USE_SRTP,
1355                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
1356         *al = SSL_AD_DECODE_ERROR;
1357         return 0;
1358     }
1359
1360     if (mki != 0) {
1361         /* Must be no MKI, since we never offer one */
1362         SSLerr(SSL_F_TLS_PARSE_STOC_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
1363         *al = SSL_AD_ILLEGAL_PARAMETER;
1364         return 0;
1365     }
1366
1367     /* Throw an error if the server gave us an unsolicited extension */
1368     clnt = SSL_get_srtp_profiles(s);
1369     if (clnt == NULL) {
1370         SSLerr(SSL_F_TLS_PARSE_STOC_USE_SRTP, SSL_R_NO_SRTP_PROFILES);
1371         *al = SSL_AD_DECODE_ERROR;
1372         return 0;
1373     }
1374
1375     /*
1376      * Check to see if the server gave us something we support (and
1377      * presumably offered)
1378      */
1379     for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) {
1380         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1381
1382         if (prof->id == id) {
1383             s->srtp_profile = prof;
1384             *al = 0;
1385             return 1;
1386         }
1387     }
1388
1389     SSLerr(SSL_F_TLS_PARSE_STOC_USE_SRTP,
1390            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
1391     *al = SSL_AD_DECODE_ERROR;
1392     return 0;
1393 }
1394 #endif
1395
1396 int tls_parse_stoc_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1397                        size_t chainidx, int *al)
1398 {
1399     /* Ignore if inappropriate ciphersuite */
1400     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
1401             && s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
1402             && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
1403         s->ext.use_etm = 1;
1404
1405     return 1;
1406 }
1407
1408 int tls_parse_stoc_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1409                        size_t chainidx, int *al)
1410 {
1411     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
1412     if (!s->hit)
1413         s->session->flags |= SSL_SESS_FLAG_EXTMS;
1414
1415     return 1;
1416 }
1417
1418 int tls_parse_stoc_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1419                              size_t chainidx, int *al)
1420 {
1421 #ifndef OPENSSL_NO_TLS1_3
1422     unsigned int group_id;
1423     PACKET encoded_pt;
1424     EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
1425
1426     /* Sanity check */
1427     if (ckey == NULL || s->s3->peer_tmp != NULL) {
1428         *al = SSL_AD_INTERNAL_ERROR;
1429         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1430         return 0;
1431     }
1432
1433     if (!PACKET_get_net_2(pkt, &group_id)) {
1434         *al = SSL_AD_DECODE_ERROR;
1435         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1436         return 0;
1437     }
1438
1439     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) {
1440         unsigned const char *pcurves = NULL;
1441         size_t i, num_curves;
1442
1443         if (PACKET_remaining(pkt) != 0) {
1444             *al = SSL_AD_DECODE_ERROR;
1445             SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1446             return 0;
1447         }
1448
1449         /*
1450          * It is an error if the HelloRetryRequest wants a key_share that we
1451          * already sent in the first ClientHello
1452          */
1453         if (group_id == s->s3->group_id) {
1454             *al = SSL_AD_ILLEGAL_PARAMETER;
1455             SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1456             return 0;
1457         }
1458
1459         /* Validate the selected group is one we support */
1460         if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1461             SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1462             return 0;
1463         }
1464         for (i = 0; i < num_curves; i++, pcurves += 2) {
1465             if (group_id == bytestogroup(pcurves))
1466                 break;
1467         }
1468         if (i >= num_curves
1469                 || !tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
1470             *al = SSL_AD_ILLEGAL_PARAMETER;
1471             SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1472             return 0;
1473         }
1474
1475         s->s3->group_id = group_id;
1476         EVP_PKEY_free(s->s3->tmp.pkey);
1477         s->s3->tmp.pkey = NULL;
1478         return 1;
1479     }
1480
1481     if (group_id != s->s3->group_id) {
1482         /*
1483          * This isn't for the group that we sent in the original
1484          * key_share!
1485          */
1486         *al = SSL_AD_ILLEGAL_PARAMETER;
1487         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1488         return 0;
1489     }
1490
1491     if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt)
1492             || PACKET_remaining(&encoded_pt) == 0) {
1493         *al = SSL_AD_DECODE_ERROR;
1494         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1495         return 0;
1496     }
1497
1498     skey = ssl_generate_pkey(ckey);
1499     if (skey == NULL) {
1500         *al = SSL_AD_INTERNAL_ERROR;
1501         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, ERR_R_MALLOC_FAILURE);
1502         return 0;
1503     }
1504     if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
1505                                         PACKET_remaining(&encoded_pt))) {
1506         *al = SSL_AD_ILLEGAL_PARAMETER;
1507         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_ECPOINT);
1508         EVP_PKEY_free(skey);
1509         return 0;
1510     }
1511
1512     if (ssl_derive(s, ckey, skey, 1) == 0) {
1513         *al = SSL_AD_INTERNAL_ERROR;
1514         SSLerr(SSL_F_TLS_PARSE_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1515         EVP_PKEY_free(skey);
1516         return 0;
1517     }
1518     s->s3->peer_tmp = skey;
1519 #endif
1520
1521     return 1;
1522 }
1523
1524 int tls_parse_stoc_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1525                        size_t chainidx, int *al)
1526 {
1527     PACKET cookie;
1528
1529     if (!PACKET_as_length_prefixed_2(pkt, &cookie)
1530             || !PACKET_memdup(&cookie, &s->ext.tls13_cookie,
1531                               &s->ext.tls13_cookie_len)) {
1532         *al = SSL_AD_DECODE_ERROR;
1533         SSLerr(SSL_F_TLS_PARSE_STOC_COOKIE, SSL_R_LENGTH_MISMATCH);
1534         return 0;
1535     }
1536
1537     return 1;
1538 }
1539
1540 int tls_parse_stoc_early_data(SSL *s, PACKET *pkt, unsigned int context,
1541                               X509 *x, size_t chainidx, int *al)
1542 {
1543     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
1544         unsigned long max_early_data;
1545
1546         if (!PACKET_get_net_4(pkt, &max_early_data)
1547                 || PACKET_remaining(pkt) != 0) {
1548             SSLerr(SSL_F_TLS_PARSE_STOC_EARLY_DATA,
1549                    SSL_R_INVALID_MAX_EARLY_DATA);
1550             *al = SSL_AD_DECODE_ERROR;
1551             return 0;
1552         }
1553
1554         s->session->ext.max_early_data = max_early_data;
1555
1556         return 1;
1557     }
1558
1559     if (PACKET_remaining(pkt) != 0) {
1560         *al = SSL_AD_DECODE_ERROR;
1561         return 0;
1562     }
1563
1564     if (s->ext.early_data != SSL_EARLY_DATA_REJECTED
1565             || !s->hit
1566             || s->session->ext.tick_identity != 0) {
1567         /*
1568          * If we get here then we didn't send early data, or we didn't resume
1569          * using the first identity so the server should not be accepting it.
1570          */
1571         *al = SSL_AD_ILLEGAL_PARAMETER;
1572         return 0;
1573     }
1574
1575     s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1576
1577     return 1;
1578 }
1579
1580 int tls_parse_stoc_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1581                        size_t chainidx, int *al)
1582 {
1583 #ifndef OPENSSL_NO_TLS1_3
1584     unsigned int identity;
1585
1586     if (!PACKET_get_net_2(pkt, &identity) || PACKET_remaining(pkt) != 0) {
1587         *al = SSL_AD_DECODE_ERROR;
1588         SSLerr(SSL_F_TLS_PARSE_STOC_PSK, SSL_R_LENGTH_MISMATCH);
1589         return 0;
1590     }
1591
1592     if (s->session->ext.tick_identity == (int)identity) {
1593         s->hit = 1;
1594         SSL_SESSION_free(s->psksession);
1595         s->psksession = NULL;
1596         return 1;
1597     }
1598
1599     if (s->psksession == NULL
1600             || s->psksession->ext.tick_identity != (int)identity) {
1601         *al = SSL_AD_ILLEGAL_PARAMETER;
1602         SSLerr(SSL_F_TLS_PARSE_STOC_PSK, SSL_R_BAD_PSK_IDENTITY);
1603         return 0;
1604     }
1605
1606     SSL_SESSION_free(s->session);
1607     s->session = s->psksession;
1608     s->psksession = NULL;
1609     memcpy(s->early_secret, s->session->early_secret, EVP_MAX_MD_SIZE);
1610     s->hit = 1;
1611 #endif
1612
1613     return 1;
1614 }