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     const 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;
 348     custom_ext_methods *exts = NULL;
 349     RAW_EXTENSION *raw_extensions = NULL;
 350     const EXTENSION_DEFINITION *thisexd;
 351
 352     /*
 353      * Initialise server side custom extensions. Client side is done during
 354      * construction of extensions for the ClientHello.
 355      */
 356     if ((context & EXT_CLIENT_HELLO) != 0) {
 357         exts = &s->cert->srv_ext;
 358         custom_ext_init(&s->cert->srv_ext);
 359     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 360         exts = &s->cert->cli_ext;
 361     }
 362
 363     raw_extensions = OPENSSL_zalloc((OSSL_NELEM(ext_defs)
 364                                      + (exts != NULL ? exts->meths_count : 0))
 365                                      * sizeof(*raw_extensions));
 366     if (raw_extensions == NULL) {
 367         *al = SSL_AD_INTERNAL_ERROR;
 368         SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
 369         return 0;
 370     }
 371
 372     while (PACKET_remaining(&extensions) > 0) {
 373         unsigned int type;
 374         PACKET extension;
 375         RAW_EXTENSION *thisex;
 376
 377         if (!PACKET_get_net_2(&extensions, &type) ||
 378             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
 379             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 380             *al = SSL_AD_DECODE_ERROR;
 381             goto err;
 382         }
 383         /*
 384          * Verify this extension is allowed. We only check duplicates for
 385          * extensions that we recognise.
 386          */
 387         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
 388                 || (thisex != NULL && thisex->present == 1)) {
 389             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 390             *al = SSL_AD_ILLEGAL_PARAMETER;
 391             goto err;
 392         }
 393         if (thisex != NULL) {
 394             thisex->data = extension;
 395             thisex->present = 1;
 396             thisex->type = type;
 397         }
 398     }
 399
 400     /*
 401      * Initialise all known extensions relevant to this context, whether we have
 402      * found them or not
 403      */
 404     for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 405         if(thisexd->init != NULL && (thisexd->context & context) != 0
 406                 && extension_is_relevant(s, thisexd->context, context)
 407                 && !thisexd->init(s, context)) {
 408             *al = SSL_AD_INTERNAL_ERROR;
 409             goto err;
 410         }
 411     }
 412
 413     *res = raw_extensions;
 414     return 1;
 415
 416  err:
 417     OPENSSL_free(raw_extensions);
 418     return 0;
 419 }
 420
 421 /*
 422  * Runs the parser for a given extension with index |idx|. |exts| contains the
 423  * list of all parsed extensions previously collected by
 424  * tls_collect_extensions(). The parser is only run if it is applicable for the
 425  * given |context| and the parser has not already been run. Returns 1 on success
 426  * or 0 on failure. In the event of a failure |*al| is populated with a suitable
 427  * alert code. If an extension is not present this counted as success.
 428  */
 429 int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
 430                         RAW_EXTENSION *exts, int *al)
 431 {
 432     RAW_EXTENSION *currext = &exts[idx];
 433     int (*parser)(SSL *s, PACKET *pkt, int *al) = NULL;
 434
 435     /* Skip if the extension is not present */
 436     if (!currext->present)
 437         return 1;
 438
 439     if (s->tlsext_debug_cb)
 440         s->tlsext_debug_cb(s, !s->server, currext->type,
 441                            PACKET_data(&currext->data),
 442                            PACKET_remaining(&currext->data),
 443                            s->tlsext_debug_arg);
 444
 445     /* Skip if we've already parsed this extension */
 446     if (currext->parsed)
 447         return 1;
 448
 449     currext->parsed = 1;
 450
 451     if (idx < OSSL_NELEM(ext_defs)) {
 452         /* We are handling a built-in extension */
 453         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
 454
 455         /* Check if extension is defined for our protocol. If not, skip */
 456         if (!extension_is_relevant(s, extdef->context, context))
 457             return 1;
 458
 459         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
 460
 461         if (parser != NULL)
 462             return parser(s, &currext->data, al);
 463
 464         /*
 465          * If the parser is NULL we fall through to the custom extension
 466          * processing
 467          */
 468     }
 469
 470     /*
 471      * This is a custom extension. We only allow this if it is a non
 472      * resumed session on the server side.
 473      *
 474      * TODO(TLS1.3): We only allow old style <=TLS1.2 custom extensions.
 475      * We're going to need a new mechanism for TLS1.3 to specify which
 476      * messages to add the custom extensions to.
 477      */
 478     if ((!s->hit || !s->server)
 479             && (context
 480                 & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 481             && custom_ext_parse(s, s->server, currext->type,
 482                                 PACKET_data(&currext->data),
 483                                 PACKET_remaining(&currext->data),
 484                                 al) <= 0)
 485         return 0;
 486
 487     return 1;
 488 }
 489
 490 /*
 491  * Parse all remaining extensions that have not yet been parsed. Also calls the
 492  * finalisation for all extensions at the end, whether we collected them or not.
 493  * Returns 1 for success or 0 for failure. On failure, |*al| is populated with a
 494  * suitable alert code.
 495  */
 496 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, int *al)
 497 {
 498     size_t i, numexts = OSSL_NELEM(ext_defs);
 499     const EXTENSION_DEFINITION *thisexd;
 500
 501     /* Calculate the number of extensions in the extensions list */
 502     if ((context & EXT_CLIENT_HELLO) != 0) {
 503         numexts += s->cert->srv_ext.meths_count;
 504     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 505         numexts += s->cert->cli_ext.meths_count;
 506     }
 507
 508     /* Parse each extension in turn */
 509     for (i = 0; i < numexts; i++) {
 510         if (!tls_parse_extension(s, i, context, exts, al))
 511             return 0;
 512     }
 513
 514     /*
 515      * Finalise all known extensions relevant to this context, whether we have
 516      * found them or not
 517      */
 518     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 519         if(thisexd->final != NULL
 520                 && (thisexd->context & context) != 0
 521                 && !thisexd->final(s, context, exts[i].present, al))
 522             return 0;
 523     }
 524
 525     return 1;
 526 }
 527
 528 /*
 529  * Construct all the extensions relevant to the current |context| and write
 530  * them to |pkt|. Returns 1 on success or 0 on failure. If a failure occurs then
 531  * |al| is populated with a suitable alert code. On a failure construction stops
 532  * at the first extension to fail to construct.
 533  */
 534 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
 535                              int *al)
 536 {
 537     size_t i;
 538     int addcustom = 0, min_version, max_version = 0, reason, tmpal;
 539     const EXTENSION_DEFINITION *thisexd;
 540
 541     /*
 542      * Normally if something goes wrong during construction it's an internal
 543      * error. We can always override this later.
 544      */
 545     tmpal = SSL_AD_INTERNAL_ERROR;
 546
 547     if (!WPACKET_start_sub_packet_u16(pkt)
 548                /*
 549                 * If extensions are of zero length then we don't even add the
 550                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
 551                 */
 552             || ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 553                && s->version == SSL3_VERSION
 554                && !WPACKET_set_flags(pkt,
 555                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
 556         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 557         goto err;
 558     }
 559
 560     if ((context & EXT_CLIENT_HELLO) != 0) {
 561         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
 562         if (reason != 0) {
 563             SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, reason);
 564             goto err;
 565         }
 566     }
 567
 568     /* Add custom extensions first */
 569     if ((context & EXT_CLIENT_HELLO) != 0) {
 570         custom_ext_init(&s->cert->cli_ext);
 571         addcustom = 1;
 572     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 573         /*
 574          * We already initialised the custom extensions during ClientHello
 575          * parsing.
 576          *
 577          * TODO(TLS1.3): We're going to need a new custom extension mechanism
 578          * for TLS1.3, so that custom extensions can specify which of the
 579          * multiple message they wish to add themselves to.
 580          */
 581         addcustom = 1;
 582     }
 583
 584     if (addcustom && !custom_ext_add(s, s->server, pkt, &tmpal)) {
 585         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 586         goto err;
 587     }
 588
 589     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
 590         int (*construct)(SSL *s, WPACKET *pkt, int *al);
 591
 592         /* Skip if not relevant for our context */
 593         if ((thisexd->context & context) == 0)
 594             continue;
 595
 596         construct = s->server ? thisexd->construct_stoc
 597                               : thisexd->construct_ctos;
 598
 599         /* Check if this extension is defined for our protocol. If not, skip */
 600         if ((SSL_IS_DTLS(s)
 601                     && (thisexd->context & EXT_TLS_IMPLEMENTATION_ONLY)
 602                        != 0)
 603                 || (s->version == SSL3_VERSION
 604                         && (thisexd->context & EXT_SSL3_ALLOWED) == 0)
 605                 || (SSL_IS_TLS13(s)
 606                     && (thisexd->context & EXT_TLS1_2_AND_BELOW_ONLY)
 607                        != 0)
 608                 || (!SSL_IS_TLS13(s)
 609                     && (thisexd->context & EXT_TLS1_3_ONLY) != 0
 610                     && (context & EXT_CLIENT_HELLO) == 0)
 611                 || ((thisexd->context & EXT_TLS1_3_ONLY) != 0
 612                     && (context & EXT_CLIENT_HELLO) != 0
 613                     && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION))
 614                 || construct == NULL)
 615             continue;
 616
 617         if (!construct(s, pkt, &tmpal))
 618             goto err;
 619     }
 620
 621     if (!WPACKET_close(pkt)) {
 622         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 623         goto err;
 624     }
 625
 626     return 1;
 627
 628  err:
 629     *al = tmpal;
 630     return 0;
 631 }
 632
 633 /*
 634  * Built in extension finalisation and initialisation functions. All initialise
 635  * or finalise the associated extension type for the given |context|. For
 636  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
 637  * otherwise. These functions return 1 on success or 0 on failure. In the event
 638  * of a failure then |*al| is populated with a suitable error code.
 639  */
 640
 641 static int final_renegotiate(SSL *s, unsigned int context, int sent,
 642                                      int *al)
 643 {
 644     if (!s->server) {
 645         /*
 646          * Check if we can connect to a server that doesn't support safe
 647          * renegotiation
 648          */
 649         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
 650                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
 651                 && !sent) {
 652             *al = SSL_AD_HANDSHAKE_FAILURE;
 653             SSLerr(SSL_F_TLS_EXT_FINAL_RENEGOTIATE,
 654                    SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
 655             return 0;
 656         }
 657
 658         return 1;
 659     }
 660
 661     /* Need RI if renegotiating */
 662     if (s->renegotiate
 663             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
 664             && !sent) {
 665         *al = SSL_AD_HANDSHAKE_FAILURE;
 666         SSLerr(SSL_F_TLS_EXT_FINAL_RENEGOTIATE,
 667                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
 668         return 0;
 669     }
 670
 671
 672     return 1;
 673 }
 674
 675 static int init_server_name(SSL *s, unsigned int context)
 676 {
 677     if (s->server)
 678         s->servername_done = 0;
 679
 680     return 1;
 681 }
 682
 683 static int final_server_name(SSL *s, unsigned int context, int sent,
 684                                      int *al)
 685 {
 686     int ret = SSL_TLSEXT_ERR_NOACK;
 687     int altmp = SSL_AD_UNRECOGNIZED_NAME;
 688
 689     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
 690         ret = s->ctx->tlsext_servername_callback(s, &altmp,
 691                                                  s->ctx->tlsext_servername_arg);
 692     else if (s->initial_ctx != NULL
 693              && s->initial_ctx->tlsext_servername_callback != 0)
 694         ret = s->initial_ctx->tlsext_servername_callback(s, &altmp,
 695                                        s->initial_ctx->tlsext_servername_arg);
 696
 697     switch (ret) {
 698     case SSL_TLSEXT_ERR_ALERT_FATAL:
 699         *al = altmp;
 700         return 0;
 701
 702     case SSL_TLSEXT_ERR_ALERT_WARNING:
 703         *al = altmp;
 704         return 1;
 705
 706     case SSL_TLSEXT_ERR_NOACK:
 707         s->servername_done = 0;
 708         return 1;
 709
 710     default:
 711         return 1;
 712     }
 713 }
 714
 715 #ifndef OPENSSL_NO_EC
 716 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
 717                                        int *al)
 718 {
 719     unsigned long alg_k, alg_a;
 720
 721     if (s->server)
 722         return 1;
 723
 724     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
 725     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
 726
 727     /*
 728      * If we are client and using an elliptic curve cryptography cipher
 729      * suite, then if server returns an EC point formats lists extension it
 730      * must contain uncompressed.
 731      */
 732     if (s->tlsext_ecpointformatlist != NULL
 733             && s->tlsext_ecpointformatlist_length > 0
 734             && s->session->tlsext_ecpointformatlist != NULL
 735             && s->session->tlsext_ecpointformatlist_length > 0
 736             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
 737         /* we are using an ECC cipher */
 738         size_t i;
 739         unsigned char *list = s->session->tlsext_ecpointformatlist;
 740
 741         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
 742             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
 743                 break;
 744         }
 745         if (i == s->session->tlsext_ecpointformatlist_length) {
 746             SSLerr(SSL_F_TLS_EXT_FINAL_EC_PT_FORMATS,
 747                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
 748             return 0;
 749         }
 750     }
 751
 752     return 1;
 753 }
 754 #endif
 755
 756 static int init_session_ticket(SSL *s, unsigned int context)
 757 {
 758     if (!s->server)
 759         s->tlsext_ticket_expected = 0;
 760
 761     return 1;
 762 }
 763
 764 static int init_status_request(SSL *s, unsigned int context)
 765 {
 766     if (s->server)
 767         s->tlsext_status_type = -1;
 768
 769     return 1;
 770 }
 771
 772 static int final_status_request(SSL *s, unsigned int context, int sent,
 773                                         int *al)
 774 {
 775     if (s->server)
 776         return 1;
 777
 778     /*
 779      * Ensure we get sensible values passed to tlsext_status_cb in the event
 780      * that we don't receive a status message
 781      */
 782     OPENSSL_free(s->tlsext_ocsp_resp);
 783     s->tlsext_ocsp_resp = NULL;
 784     s->tlsext_ocsp_resplen = 0;
 785
 786     return 1;
 787 }
 788
 789 #ifndef OPENSSL_NO_NEXTPROTONEG
 790 static int init_npn(SSL *s, unsigned int context)
 791 {
 792     s->s3->next_proto_neg_seen = 0;
 793
 794     return 1;
 795 }
 796 #endif
 797
 798 static int init_alpn(SSL *s, unsigned int context)
 799 {
 800     OPENSSL_free(s->s3->alpn_selected);
 801     s->s3->alpn_selected = NULL;
 802     if (s->server) {
 803         s->s3->alpn_selected_len = 0;
 804         OPENSSL_free(s->s3->alpn_proposed);
 805         s->s3->alpn_proposed = NULL;
 806         s->s3->alpn_proposed_len = 0;
 807     }
 808     return 1;
 809 }
 810
 811 static int final_alpn(SSL *s, unsigned int context, int sent, int *al)
 812 {
 813     const unsigned char *selected = NULL;
 814     unsigned char selected_len = 0;
 815
 816     if (!s->server)
 817         return 1;
 818
 819     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
 820         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
 821                                        s->s3->alpn_proposed,
 822                                        (unsigned int)s->s3->alpn_proposed_len,
 823                                        s->ctx->alpn_select_cb_arg);
 824
 825         if (r == SSL_TLSEXT_ERR_OK) {
 826             OPENSSL_free(s->s3->alpn_selected);
 827             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
 828             if (s->s3->alpn_selected == NULL) {
 829                 *al = SSL_AD_INTERNAL_ERROR;
 830                 return 0;
 831             }
 832             s->s3->alpn_selected_len = selected_len;
 833 #ifndef OPENSSL_NO_NEXTPROTONEG
 834             /* ALPN takes precedence over NPN. */
 835             s->s3->next_proto_neg_seen = 0;
 836 #endif
 837         } else {
 838             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
 839             return 0;
 840         }
 841     }
 842
 843     return 1;
 844 }
 845
 846 static int init_sig_algs(SSL *s, unsigned int context)
 847 {
 848     /* Clear any signature algorithms extension received */
 849     OPENSSL_free(s->s3->tmp.peer_sigalgs);
 850     s->s3->tmp.peer_sigalgs = NULL;
 851
 852     return 1;
 853 }
 854
 855 #ifndef OPENSSL_NO_SRP
 856 static int init_srp(SSL *s, unsigned int context)
 857 {
 858     OPENSSL_free(s->srp_ctx.login);
 859     s->srp_ctx.login = NULL;
 860
 861     return 1;
 862 }
 863 #endif
 864
 865 static int init_etm(SSL *s, unsigned int context)
 866 {
 867     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
 868
 869     return 1;
 870 }
 871
 872 static int init_ems(SSL *s, unsigned int context)
 873 {
 874     if (!s->server)
 875         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
 876
 877     return 1;
 878 }
 879
 880 static int final_ems(SSL *s, unsigned int context, int sent, int *al)
 881 {
 882     if (!s->server && s->hit) {
 883         /*
 884          * Check extended master secret extension is consistent with
 885          * original session.
 886          */
 887         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
 888             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
 889             *al = SSL_AD_HANDSHAKE_FAILURE;
 890             SSLerr(SSL_F_TLS_EXT_FINAL_EMS, SSL_R_INCONSISTENT_EXTMS);
 891             return 0;
 892         }
 893     }
 894
 895     return 1;
 896 }
 897
 898 #ifndef OPENSSL_NO_SRTP
 899 static int init_srtp(SSL *s, unsigned int context)
 900 {
 901     if (s->server)
 902         s->srtp_profile = NULL;
 903
 904     return 1;
 905 }
 906 #endif