ssl/statem/extensions.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 "../ssl_locl.h"
  11 #include "statem_locl.h"
  12
  13 static int final_renegotiate(SSL *s, unsigned int context, int sent,
  14                                      int *al);
  15 static int init_server_name(SSL *s, unsigned int context);
  16 static int final_server_name(SSL *s, unsigned int context, int sent,
  17                                      int *al);
  18 #ifndef OPENSSL_NO_EC
  19 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
  20                                        int *al);
  21 #endif
  22 static int init_session_ticket(SSL *s, unsigned int context);
  23 static int init_status_request(SSL *s, unsigned int context);
  24 static int final_status_request(SSL *s, unsigned int context, int sent,
  25                                         int *al);
  26 #ifndef OPENSSL_NO_NEXTPROTONEG
  27 static int init_npn(SSL *s, unsigned int context);
  28 #endif
  29 static int init_alpn(SSL *s, unsigned int context);
  30 static int final_alpn(SSL *s, unsigned int context, int sent, int *al);
  31 static int init_sig_algs(SSL *s, unsigned int context);
  32 #ifndef OPENSSL_NO_SRP
  33 static int init_srp(SSL *s, unsigned int context);
  34 #endif
  35 static int init_etm(SSL *s, unsigned int context);
  36 static int init_ems(SSL *s, unsigned int context);
  37 static int final_ems(SSL *s, unsigned int context, int sent, int *al);
  38 #ifndef OPENSSL_NO_SRTP
  39 static int init_srtp(SSL *s, unsigned int context);
  40 #endif
  41
  42 /* Structure to define a built-in extension */
  43 typedef struct extensions_definition_st {
  44     /* The defined type for the extension */
  45     unsigned int type;
  46     /*
  47      * The context that this extension applies to, e.g. what messages and
  48      * protocol versions
  49      */
  50     unsigned int context;
  51     /*
  52      * Initialise extension before parsing. Always called for relevant contexts
  53      * even if extension not present
  54      */
  55     int (*init)(SSL *s, unsigned int context);
  56     /* Parse extension sent from client to server */
  57     int (*parse_ctos)(SSL *s, PACKET *pkt, int *al);
  58     /* Parse extension send from server to client */
  59     int (*parse_stoc)(SSL *s, PACKET *pkt, int *al);
  60     /* Construct extension sent from server to client */
  61     int (*construct_stoc)(SSL *s, WPACKET *pkt, int *al);
  62     /* Construct extension sent from client to server */
  63     int (*construct_ctos)(SSL *s, WPACKET *pkt, int *al);
  64     /*
  65      * Finalise extension after parsing. Always called where an extensions was
  66      * initialised even if the extension was not present. |sent| is set to 1 if
  67      * the extension was seen, or 0 otherwise.
  68      */
  69     int (*final)(SSL *s, unsigned int context, int sent, int *al);
  70 } EXTENSION_DEFINITION;
  71
  72 /*
  73  * Definitions of all built-in extensions. NOTE: Changes in the number or order
  74  * of these extensions should be mirrored with equivalent changes to the indexes
  75  * defined in statem_locl.h.
  76  * Each extension has an initialiser, a client and
  77  * server side parser and a finaliser. The initialiser is called (if the
  78  * extension is relevant to the given context) even if we did not see the
  79  * extension in the message that we received. The parser functions are only
  80  * called if we see the extension in the message. The finalisers are always
  81  * called if the initialiser was called.
  82  * There are also server and client side constructor functions which are always
  83  * called during message construction if the extension is relevant for the
  84  * given context.
  85  * The initialisation, parsing, finalisation and construction functions are
  86  * always called in the order defined in this list. Some extensions may depend
  87  * on others having been processed first, so the order of this list is
  88  * significant.
  89  * The extension context is defined by a series of flags which specify which
  90  * messages the extension is relevant to. These flags also specify whether the
  91  * extension is relevant to a paricular protocol or protocol version.
  92  *
  93  * TODO(TLS1.3): Make sure we have a test to check the consistency of these
  94  */
  95 static const EXTENSION_DEFINITION ext_defs[] = {
  96     {
  97         TLSEXT_TYPE_renegotiate,
  98         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_SSL3_ALLOWED
  99         | EXT_TLS1_2_AND_BELOW_ONLY,
 100         NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate,
 101         tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate,
 102         final_renegotiate
 103     },
 104     {
 105         TLSEXT_TYPE_server_name,
 106         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 107         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
 108         init_server_name,
 109         tls_parse_ctos_server_name, tls_parse_stoc_server_name,
 110         tls_construct_stoc_server_name, tls_construct_ctos_server_name,
 111         final_server_name
 112     },
 113 #ifndef OPENSSL_NO_SRP
 114     {
 115         TLSEXT_TYPE_srp,
 116         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 117         init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL
 118     },
 119 #endif
 120 #ifndef OPENSSL_NO_EC
 121     {
 122         TLSEXT_TYPE_ec_point_formats,
 123         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 124         NULL, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats,
 125         tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats,
 126         final_ec_pt_formats
 127     },
 128     {
 129         TLSEXT_TYPE_supported_groups,
 130         EXT_CLIENT_HELLO | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
 131         NULL, tls_parse_ctos_supported_groups, NULL,
 132         NULL /* TODO(TLS1.3): Need to add this */,
 133         tls_construct_ctos_supported_groups, NULL
 134     },
 135 #endif
 136     {
 137         TLSEXT_TYPE_session_ticket,
 138         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 139         init_session_ticket, tls_parse_ctos_session_ticket,
 140         tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket,
 141         tls_construct_ctos_session_ticket, NULL
 142     },
 143     {
 144         TLSEXT_TYPE_signature_algorithms,
 145         EXT_CLIENT_HELLO,
 146         init_sig_algs, tls_parse_ctos_sig_algs, NULL, NULL,
 147         tls_construct_ctos_sig_algs, NULL
 148     },
 149 #ifndef OPENSSL_NO_OCSP
 150     {
 151         TLSEXT_TYPE_status_request,
 152         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 153         | EXT_TLS1_3_CERTIFICATE,
 154         init_status_request, tls_parse_ctos_status_request,
 155         tls_parse_stoc_status_request, tls_construct_stoc_status_request,
 156         tls_construct_ctos_status_request, final_status_request
 157     },
 158 #endif
 159 #ifndef OPENSSL_NO_NEXTPROTONEG
 160     {
 161         TLSEXT_TYPE_next_proto_neg,
 162         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 163         init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn,
 164         tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL
 165     },
 166 #endif
 167     {
 168         /*
 169          * Must appear in this list after server_name so that finalisation
 170          * happens after server_name callbacks
 171          */
 172         TLSEXT_TYPE_application_layer_protocol_negotiation,
 173         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 174         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
 175         init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn,
 176         tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn
 177     },
 178 #ifndef OPENSSL_NO_SRTP
 179     {
 180         TLSEXT_TYPE_use_srtp,
 181         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 182         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS | EXT_DTLS_ONLY,
 183         init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp,
 184         tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL
 185     },
 186 #endif
 187     {
 188         TLSEXT_TYPE_encrypt_then_mac,
 189         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 190         init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm,
 191         tls_construct_stoc_etm, tls_construct_ctos_etm, NULL
 192     },
 193 #ifndef OPENSSL_NO_CT
 194     {
 195         TLSEXT_TYPE_signed_certificate_timestamp,
 196         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 197         | EXT_TLS1_3_CERTIFICATE,
 198         NULL,
 199         /*
 200          * No server side support for this, but can be provided by a custom
 201          * extension. This is an exception to the rule that custom extensions
 202          * cannot override built in ones.
 203          */
 204         NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct,  NULL
 205     },
 206 #endif
 207     {
 208         TLSEXT_TYPE_extended_master_secret,
 209         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 210         init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems,
 211         tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems
 212     },
 213     {
 214         TLSEXT_TYPE_supported_versions,
 215         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY | EXT_TLS1_3_ONLY,
 216         NULL,
 217         /* Processed inline as part of version selection */
 218         NULL, NULL, NULL, tls_construct_ctos_supported_versions, NULL
 219     },
 220     {
 221         /*
 222          * Must be in this list after supported_groups. We need that to have
 223          * been parsed before we do this one.
 224          */
 225         TLSEXT_TYPE_key_share,
 226         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO
 227         | EXT_TLS1_3_HELLO_RETRY_REQUEST | EXT_TLS_IMPLEMENTATION_ONLY
 228         | EXT_TLS1_3_ONLY,
 229         NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share,
 230         tls_construct_stoc_key_share, tls_construct_ctos_key_share, NULL
 231     },
 232     {
 233         /*
 234          * Special unsolicited ServerHello extension only used when
 235          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set
 236          */
 237         TLSEXT_TYPE_cryptopro_bug,
 238         EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
 239         NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
 240     },
 241     {
 242         /* Last in the list because it must be added as the last extension */
 243         TLSEXT_TYPE_padding,
 244         EXT_CLIENT_HELLO,
 245         NULL,
 246         /* We send this, but don't read it */
 247         NULL, NULL, NULL, tls_construct_ctos_padding, NULL
 248     }
 249 };
 250
 251 /*
 252  * Verify whether we are allowed to use the extension |type| in the current
 253  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
 254  * indicate the extension is not allowed. If returning 1 then |*found| is set to
 255  * 1 if we found a definition for the extension, and |*idx| is set to its index
 256  */
 257 static int verify_extension(SSL *s, unsigned int context, unsigned int type,
 258                             custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
 259                             RAW_EXTENSION **found)
 260 {
 261     size_t i;
 262     size_t builtin_num = OSSL_NELEM(ext_defs);
 263     EXTENSION_DEFINITION *thisext;
 264
 265     for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) {
 266         if (type == thisext->type) {
 267             /* Check we're allowed to use this extension in this context */
 268             if ((context & thisext->context) == 0)
 269                 return 0;
 270
 271             if (SSL_IS_DTLS(s)) {
 272                 if ((thisext->context & EXT_TLS_ONLY) != 0)
 273                     return 0;
 274             } else if ((thisext->context & EXT_DTLS_ONLY) != 0) {
 275                     return 0;
 276             }
 277
 278             *found = &rawexlist[i];
 279             return 1;
 280         }
 281     }
 282
 283     if ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) == 0) {
 284         /*
 285          * Custom extensions only apply to <=TLS1.2. This extension is unknown
 286          * in this context - we allow it
 287          */
 288         *found = NULL;
 289         return 1;
 290     }
 291
 292     /* Check the custom extensions */
 293     if (meths != NULL) {
 294         for (i = builtin_num; i < builtin_num + meths->meths_count; i++) {
 295             if (meths->meths[i - builtin_num].ext_type == type) {
 296                 *found = &rawexlist[i];
 297                 return 1;
 298             }
 299         }
 300     }
 301
 302     /* Unknown extension. We allow it */
 303     *found = NULL;
 304     return 1;
 305 }
 306
 307 /*
 308  * Check whether the context defined for an extension |extctx| means whether
 309  * the extension is relevant for the current context |thisctx| or not. Returns
 310  * 1 if the extension is relevant for this context, and 0 otherwise
 311  */
 312 static int extension_is_relevant(SSL *s, unsigned int extctx,
 313                                  unsigned int thisctx)
 314 {
 315     if ((SSL_IS_DTLS(s)
 316                 && (extctx & EXT_TLS_IMPLEMENTATION_ONLY) != 0)
 317             || (s->version == SSL3_VERSION
 318                     && (extctx & EXT_SSL3_ALLOWED) == 0)
 319             || (SSL_IS_TLS13(s)
 320                 && (extctx & EXT_TLS1_2_AND_BELOW_ONLY) != 0)
 321             || (!SSL_IS_TLS13(s) && (extctx & EXT_TLS1_3_ONLY) != 0))
 322         return 0;
 323
 324     return 1;
 325 }
 326
 327 /*
 328  * Gather a list of all the extensions from the data in |packet]. |context|
 329  * tells us which message this extension is for. The raw extension data is
 330  * stored in |*res| on success. In the event of an error the alert type to use
 331  * is stored in |*al|. We don't actually process the content of the extensions
 332  * yet, except to check their types. This function also runs the initialiser
 333  * functions for all known extensions (whether we have collected them or not).
 334  * If successful the caller is responsible for freeing the contents of |*res|.
 335  *
 336  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
 337  * more than one extension of the same type in a ClientHello or ServerHello.
 338  * This function returns 1 if all extensions are unique and we have parsed their
 339  * types, and 0 if the extensions contain duplicates, could not be successfully
 340  * found, or an internal error occurred. We only check duplicates for
 341  * extensions that we know about. We ignore others.
 342  */
 343 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
 344                            RAW_EXTENSION **res, int *al)
 345 {
 346     PACKET extensions = *packet;
 347     size_t i = 0, idx;
 348     int found = 0;
 349     custom_ext_methods *exts = NULL;
 350     RAW_EXTENSION *raw_extensions = NULL;
 351     EXTENSION_DEFINITION *thisexd;
 352
 353     /*
 354      * Initialise server side custom extensions. Client side is done during
 355      * construction of extensions for the ClientHello.
 356      */
 357     if ((context & EXT_CLIENT_HELLO) != 0) {
 358         exts = &s->cert->srv_ext;
 359         custom_ext_init(&s->cert->srv_ext);
 360     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 361         exts = &s->cert->cli_ext;
 362     }
 363
 364     raw_extensions = OPENSSL_zalloc((OSSL_NELEM(ext_defs)
 365                                      + (exts != NULL ? exts->meths_count : 0))
 366                                      * sizeof(*raw_extensions));
 367     if (raw_extensions == NULL) {
 368         *al = SSL_AD_INTERNAL_ERROR;
 369         SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
 370         return 0;
 371     }
 372
 373     while (PACKET_remaining(&extensions) > 0) {
 374         unsigned int type;
 375         PACKET extension;
 376         RAW_EXTENSION *thisex;
 377
 378         if (!PACKET_get_net_2(&extensions, &type) ||
 379             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
 380             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 381             *al = SSL_AD_DECODE_ERROR;
 382             goto err;
 383         }
 384         /*
 385          * Verify this extension is allowed. We only check duplicates for
 386          * extensions that we recognise.
 387          */
 388         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
 389                 || (thisex != NULL && thisex->present == 1)) {
 390             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 391             *al = SSL_AD_ILLEGAL_PARAMETER;
 392             goto err;
 393         }
 394         if (thisex != NULL) {
 395             thisex->data = extension;
 396             thisex->present = 1;
 397             thisex->type = type;
 398         }
 399     }
 400
 401     /*
 402      * Initialise all known extensions relevant to this context, whether we have
 403      * found them or not
 404      */
 405     for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 406         if(thisexd->init != NULL && (thisexd->context & context) != 0
 407                 && extension_is_relevant(s, thisexd->context, context)
 408                 && !thisexd->init(s, context)) {
 409             *al = SSL_AD_INTERNAL_ERROR;
 410             goto err;
 411         }
 412     }
 413
 414     *res = raw_extensions;
 415     return 1;
 416
 417  err:
 418     OPENSSL_free(raw_extensions);
 419     return 0;
 420 }
 421
 422 /*
 423  * Runs the parser for a given extension with index |idx|. |exts| contains the
 424  * list of all parsed extensions previously collected by
 425  * tls_collect_extensions(). The parser is only run if it is applicable for the
 426  * given |context| and the parser has not already been run. Returns 1 on success
 427  * or 0 on failure. In the event of a failure |*al| is populated with a suitable
 428  * alert code. If an extension is not present this counted as success.
 429  */
 430 int tls_parse_extension(SSL *s, unsigned int idx, int context,
 431                         RAW_EXTENSION *exts, int *al)
 432 {
 433     RAW_EXTENSION *currext = &exts[idx];
 434     int (*parser)(SSL *s, PACKET *pkt, int *al) = NULL;
 435
 436     /* Skip if the extension is not present */
 437     if (!currext->present)
 438         return 1;
 439
 440     if (s->tlsext_debug_cb)
 441         s->tlsext_debug_cb(s, !s->server, currext->type,
 442                            PACKET_data(&currext->data),
 443                            PACKET_remaining(&currext->data),
 444                            s->tlsext_debug_arg);
 445
 446     /* Skip if we've already parsed this extension */
 447     if (currext->parsed)
 448         return 1;
 449
 450     currext->parsed = 1;
 451
 452     if (idx < OSSL_NELEM(ext_defs)) {
 453         /* We are handling a built-in extension */
 454         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
 455
 456         /* Check if extension is defined for our protocol. If not, skip */
 457         if (!extension_is_relevant(s, extdef->context, context))
 458             return 1;
 459
 460         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
 461
 462         if (parser != NULL)
 463             return parser(s, &currext->data, al);
 464
 465         /*
 466          * If the parser is NULL we fall through to the custom extension
 467          * processing
 468          */
 469     }
 470
 471     /*
 472      * This is a custom extension. We only allow this if it is a non
 473      * resumed session on the server side.
 474      *
 475      * TODO(TLS1.3): We only allow old style <=TLS1.2 custom extensions.
 476      * We're going to need a new mechanism for TLS1.3 to specify which
 477      * messages to add the custom extensions to.
 478      */
 479     if ((!s->hit || !s->server)
 480             && (context
 481                 & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 482             && custom_ext_parse(s, s->server, currext->type,
 483                                 PACKET_data(&currext->data),
 484                                 PACKET_remaining(&currext->data),
 485                                 al) <= 0)
 486         return 0;
 487
 488     return 1;
 489 }
 490
 491 /*
 492  * Parse all remaining extensions that have not yet been parsed. Also calls the
 493  * finalisation for all extensions at the end, whether we collected them or not.
 494  * Returns 1 for success or 0 for failure. On failure, |*al| is populated with a
 495  * suitable alert code.
 496  */
 497 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, int *al)
 498 {
 499     size_t i, numexts = OSSL_NELEM(ext_defs);
 500     EXTENSION_DEFINITION *thisexd;
 501
 502     /* Calculate the number of extensions in the extensions list */
 503     if ((context & EXT_CLIENT_HELLO) != 0) {
 504         numexts += s->cert->srv_ext.meths_count;
 505     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 506         numexts += s->cert->cli_ext.meths_count;
 507     }
 508
 509     /* Parse each extension in turn */
 510     for (i = 0; i < numexts; i++) {
 511         if (!tls_parse_extension(s, loop, context, exts, al))
 512             return 0;
 513     }
 514
 515     /*
 516      * Finalise all known extensions relevant to this context, whether we have
 517      * found them or not
 518      */
 519     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 520         if(thisexd->final != NULL
 521                 && (thisexd->context & context) != 0
 522                 && !thisexd->final(s, context, exts[i].present, al))
 523             return 0;
 524     }
 525
 526     return 1;
 527 }
 528
 529 /*
 530  * Construct all the extensions relevant to the current |context| and write
 531  * them to |pkt|. Returns 1 on success or 0 on failure. If a failure occurs then
 532  * |al| is populated with a suitable alert code. On a failure construction stops
 533  * at the first extension to fail to construct.
 534  */
 535 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
 536                              int *al)
 537 {
 538     size_t i;
 539     int addcustom = 0, min_version, max_version = 0, reason, tmpal;
 540     EXTENSION_DEFINITION *thisexd;
 541
 542     /*
 543      * Normally if something goes wrong during construction it's an internal
 544      * error. We can always override this later.
 545      */
 546     tmpal = SSL_AD_INTERNAL_ERROR;
 547
 548     if (!WPACKET_start_sub_packet_u16(pkt)
 549                /*
 550                 * If extensions are of zero length then we don't even add the
 551                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
 552                 */
 553             || ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 554                && s->version == SSL3_VERSION
 555                && !WPACKET_set_flags(pkt,
 556                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
 557         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 558         goto err;
 559     }
 560
 561     if ((context & EXT_CLIENT_HELLO) != 0) {
 562         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
 563         if (reason != 0) {
 564             SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, reason);
 565             goto err;
 566         }
 567     }
 568
 569     /* Add custom extensions first */
 570     if ((context & EXT_CLIENT_HELLO) != 0) {
 571         custom_ext_init(&s->cert->cli_ext);
 572         addcustom = 1;
 573     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 574         /*
 575          * We already initialised the custom extensions during ClientHello
 576          * parsing.
 577          *
 578          * TODO(TLS1.3): We're going to need a new custom extension mechanism
 579          * for TLS1.3, so that custom extensions can specify which of the
 580          * multiple message they wish to add themselves to.
 581          */
 582         addcustom = 1;
 583     }
 584
 585     if (addcustom && !custom_ext_add(s, s->server, pkt, &tmpal)) {
 586         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 587         goto err;
 588     }
 589
 590     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 591         int (*construct)(SSL *s, WPACKET *pkt, int *al);
 592
 593         /* Skip if not relevant for our context */
 594         if ((ext_defs[loop].context & context) == 0)
 595             continue;
 596
 597         construct = s->server ? thisexd->construct_stoc
 598                               : thisexd->construct_ctos;
 599
 600         /* Check if this extension is defined for our protocol. If not, skip */
 601         if ((SSL_IS_DTLS(s)
 602                     && (thisexd->context & EXT_TLS_IMPLEMENTATION_ONLY)
 603                        != 0)
 604                 || (s->version == SSL3_VERSION
 605                         && (thisexd->context & EXT_SSL3_ALLOWED) == 0)
 606                 || (SSL_IS_TLS13(s)
 607                     && (thisexd->context & EXT_TLS1_2_AND_BELOW_ONLY)
 608                        != 0)
 609                 || (!SSL_IS_TLS13(s)
 610                     && (thisexd->context & EXT_TLS1_3_ONLY) != 0
 611                     && (context & EXT_CLIENT_HELLO) == 0)
 612                 || ((thisexd->context & EXT_TLS1_3_ONLY) != 0
 613                     && (context & EXT_CLIENT_HELLO) != 0
 614                     && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION))
 615                 || construct == NULL)
 616             continue;
 617
 618         if (!construct(s, pkt, &tmpal))
 619             goto err;
 620     }
 621
 622     if (!WPACKET_close(pkt)) {
 623         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 624         goto err;
 625     }
 626
 627     return 1;
 628
 629  err:
 630     *al = tmpal;
 631     return 0;
 632 }
 633
 634 /*
 635  * Built in extension finalisation and initialisation functions. All initialise
 636  * or finalise the associated extension type for the given |context|. For
 637  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
 638  * otherwise. These functions return 1 on success or 0 on failure. In the event
 639  * of a failure then |*al| is populated with a suitable error code.
 640  */
 641
 642 static int final_renegotiate(SSL *s, unsigned int context, int sent,
 643                                      int *al)
 644 {
 645     if (!s->server) {
 646         /*
 647          * Check if we can connect to a server that doesn't support safe
 648          * renegotiation
 649          */
 650         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
 651                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
 652                 && !sent) {
 653             *al = SSL_AD_HANDSHAKE_FAILURE;
 654             SSLerr(SSL_F_TLS_EXT_FINAL_RENEGOTIATE,
 655                    SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
 656             return 0;
 657         }
 658
 659         return 1;
 660     }
 661
 662     /* Need RI if renegotiating */
 663     if (s->renegotiate
 664             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
 665             && !sent) {
 666         *al = SSL_AD_HANDSHAKE_FAILURE;
 667         SSLerr(SSL_F_TLS_EXT_FINAL_RENEGOTIATE,
 668                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
 669         return 0;
 670     }
 671
 672
 673     return 1;
 674 }
 675
 676 static int init_server_name(SSL *s, unsigned int context)
 677 {
 678     if (s->server)
 679         s->servername_done = 0;
 680
 681     return 1;
 682 }
 683
 684 static int final_server_name(SSL *s, unsigned int context, int sent,
 685                                      int *al)
 686 {
 687     int ret = SSL_TLSEXT_ERR_NOACK;
 688     int altmp = SSL_AD_UNRECOGNIZED_NAME;
 689
 690     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
 691         ret = s->ctx->tlsext_servername_callback(s, &altmp,
 692                                                  s->ctx->tlsext_servername_arg);
 693     else if (s->initial_ctx != NULL
 694              && s->initial_ctx->tlsext_servername_callback != 0)
 695         ret = s->initial_ctx->tlsext_servername_callback(s, &altmp,
 696                                        s->initial_ctx->tlsext_servername_arg);
 697
 698     switch (ret) {
 699     case SSL_TLSEXT_ERR_ALERT_FATAL:
 700         *al = altmp;
 701         return 0;
 702
 703     case SSL_TLSEXT_ERR_ALERT_WARNING:
 704         *al = altmp;
 705         return 1;
 706
 707     case SSL_TLSEXT_ERR_NOACK:
 708         s->servername_done = 0;
 709         return 1;
 710
 711     default:
 712         return 1;
 713     }
 714 }
 715
 716 #ifndef OPENSSL_NO_EC
 717 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
 718                                        int *al)
 719 {
 720     unsigned long alg_k, alg_a;
 721
 722     if (s->server)
 723         return 1;
 724
 725     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
 726     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
 727
 728     /*
 729      * If we are client and using an elliptic curve cryptography cipher
 730      * suite, then if server returns an EC point formats lists extension it
 731      * must contain uncompressed.
 732      */
 733     if (s->tlsext_ecpointformatlist != NULL
 734             && s->tlsext_ecpointformatlist_length > 0
 735             && s->session->tlsext_ecpointformatlist != NULL
 736             && s->session->tlsext_ecpointformatlist_length > 0
 737             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
 738         /* we are using an ECC cipher */
 739         size_t i;
 740         unsigned char *list = s->session->tlsext_ecpointformatlist;
 741
 742         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
 743             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
 744                 break;
 745         }
 746         if (i == s->session->tlsext_ecpointformatlist_length) {
 747             SSLerr(SSL_F_TLS_EXT_FINAL_EC_PT_FORMATS,
 748                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
 749             return 0;
 750         }
 751     }
 752
 753     return 1;
 754 }
 755 #endif
 756
 757 static int init_session_ticket(SSL *s, unsigned int context)
 758 {
 759     if (!s->server)
 760         s->tlsext_ticket_expected = 0;
 761
 762     return 1;
 763 }
 764
 765 static int init_status_request(SSL *s, unsigned int context)
 766 {
 767     if (s->server)
 768         s->tlsext_status_type = -1;
 769
 770     return 1;
 771 }
 772
 773 static int final_status_request(SSL *s, unsigned int context, int sent,
 774                                         int *al)
 775 {
 776     if (s->server)
 777         return 1;
 778
 779     /*
 780      * Ensure we get sensible values passed to tlsext_status_cb in the event
 781      * that we don't receive a status message
 782      */
 783     OPENSSL_free(s->tlsext_ocsp_resp);
 784     s->tlsext_ocsp_resp = NULL;
 785     s->tlsext_ocsp_resplen = 0;
 786
 787     return 1;
 788 }
 789
 790 #ifndef OPENSSL_NO_NEXTPROTONEG
 791 static int init_npn(SSL *s, unsigned int context)
 792 {
 793     s->s3->next_proto_neg_seen = 0;
 794
 795     return 1;
 796 }
 797 #endif
 798
 799 static int init_alpn(SSL *s, unsigned int context)
 800 {
 801     OPENSSL_free(s->s3->alpn_selected);
 802     s->s3->alpn_selected = NULL;
 803     if (s->server) {
 804         s->s3->alpn_selected_len = 0;
 805         OPENSSL_free(s->s3->alpn_proposed);
 806         s->s3->alpn_proposed = NULL;
 807         s->s3->alpn_proposed_len = 0;
 808     }
 809     return 1;
 810 }
 811
 812 static int final_alpn(SSL *s, unsigned int context, int sent, int *al)
 813 {
 814     const unsigned char *selected = NULL;
 815     unsigned char selected_len = 0;
 816
 817     if (!s->server)
 818         return 1;
 819
 820     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
 821         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
 822                                        s->s3->alpn_proposed,
 823                                        (unsigned int)s->s3->alpn_proposed_len,
 824                                        s->ctx->alpn_select_cb_arg);
 825
 826         if (r == SSL_TLSEXT_ERR_OK) {
 827             OPENSSL_free(s->s3->alpn_selected);
 828             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
 829             if (s->s3->alpn_selected == NULL) {
 830                 *al = SSL_AD_INTERNAL_ERROR;
 831                 return 0;
 832             }
 833             s->s3->alpn_selected_len = selected_len;
 834 #ifndef OPENSSL_NO_NEXTPROTONEG
 835             /* ALPN takes precedence over NPN. */
 836             s->s3->next_proto_neg_seen = 0;
 837 #endif
 838         } else {
 839             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
 840             return 0;
 841         }
 842     }
 843
 844     return 1;
 845 }
 846
 847 static int init_sig_algs(SSL *s, unsigned int context)
 848 {
 849     /* Clear any signature algorithms extension received */
 850     OPENSSL_free(s->s3->tmp.peer_sigalgs);
 851     s->s3->tmp.peer_sigalgs = NULL;
 852
 853     return 1;
 854 }
 855
 856 #ifndef OPENSSL_NO_SRP
 857 static int init_srp(SSL *s, unsigned int context)
 858 {
 859     OPENSSL_free(s->srp_ctx.login);
 860     s->srp_ctx.login = NULL;
 861
 862     return 1;
 863 }
 864 #endif
 865
 866 static int init_etm(SSL *s, unsigned int context)
 867 {
 868     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
 869
 870     return 1;
 871 }
 872
 873 static int init_ems(SSL *s, unsigned int context)
 874 {
 875     if (!s->server)
 876         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
 877
 878     return 1;
 879 }
 880
 881 static int final_ems(SSL *s, unsigned int context, int sent, int *al)
 882 {
 883     if (!s->server && s->hit) {
 884         /*
 885          * Check extended master secret extension is consistent with
 886          * original session.
 887          */
 888         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
 889             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
 890             *al = SSL_AD_HANDSHAKE_FAILURE;
 891             SSLerr(SSL_F_TLS_EXT_FINAL_EMS, SSL_R_INCONSISTENT_EXTMS);
 892             return 0;
 893         }
 894     }
 895
 896     return 1;
 897 }
 898
 899 #ifndef OPENSSL_NO_SRTP
 900 static int init_srtp(SSL *s, unsigned int context)
 901 {
 902     if (s->server)
 903         s->srtp_profile = NULL;
 904
 905     return 1;
 906 }
 907 #endif