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