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