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