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