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 <stdlib.h>
  11 #include "../ssl_locl.h"
  12 #include "statem_locl.h"
  13
  14 typedef struct {
  15     /* The ID for the extension */
  16     unsigned int type;
  17     /*
  18      * Initialise extension before parsing. Always called even if extension not
  19      * present
  20      */
  21     int (*init_ext)(SSL *s, unsigned int context);
  22     /* Parse extension received by server from client */
  23     int (*parse_client_ext)(SSL *s, PACKET *pkt, int *al);
  24     /* Parse extension received by client from server */
  25     int (*parse_server_ext)(SSL *s, PACKET *pkt, int *al);
  26     /* Construct extension sent by server */
  27     int (*construct_server_ext)(SSL *s, WPACKET *pkt, int *al);
  28     /* Construct extension sent by client */
  29     int (*construct_client_ext)(SSL *s, WPACKET *pkt, int *al);
  30     /*
  31      * Finalise extension after parsing. Always called even if extension not
  32      * present
  33      */
  34     int (*finalise_ext)(SSL *s, unsigned int context);
  35     unsigned int context;
  36 } EXTENSION_DEFINITION;
  37
  38 /*
  39  * TODO(TLS1.3): Temporarily modified the definitions below to put all TLS1.3
  40  * extensions in the ServerHello for now. That needs to be put back to correct
  41  * setting once encrypted extensions is working properly.
  42  */
  43 static const EXTENSION_DEFINITION ext_defs[] = {
  44     {
  45         TLSEXT_TYPE_renegotiate,
  46         NULL,
  47         tls_parse_client_renegotiate,
  48         tls_parse_server_renegotiate,
  49         tls_construct_server_renegotiate,
  50         tls_construct_client_renegotiate,
  51         NULL,
  52         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_SSL3_ALLOWED
  53         | EXT_TLS1_2_AND_BELOW_ONLY
  54     },
  55     {
  56         TLSEXT_TYPE_server_name,
  57         NULL,
  58         tls_parse_client_server_name,
  59         tls_parse_server_server_name,
  60         tls_construct_server_server_name,
  61         tls_construct_client_server_name,
  62         NULL,
  63         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
  64         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
  65     },
  66 #ifndef OPENSSL_NO_SRP
  67     {
  68         TLSEXT_TYPE_srp,
  69         NULL,
  70         tls_parse_client_srp,
  71         NULL,
  72         NULL,
  73         tls_construct_client_srp,
  74         NULL,
  75         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
  76     },
  77 #endif
  78 #ifndef OPENSSL_NO_EC
  79     {
  80         TLSEXT_TYPE_ec_point_formats,
  81         NULL,
  82         tls_parse_client_ec_pt_formats,
  83         tls_parse_server_ec_pt_formats,
  84         tls_construct_server_ec_pt_formats,
  85         tls_construct_client_ec_pt_formats,
  86         NULL,
  87         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
  88     },
  89     {
  90         TLSEXT_TYPE_supported_groups,
  91         NULL,
  92         tls_parse_client_supported_groups,
  93         NULL,
  94         NULL /* TODO(TLS1.3): Need to add this */,
  95         tls_construct_client_supported_groups,
  96         NULL,
  97         EXT_CLIENT_HELLO | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
  98     },
  99 #endif
 100     {
 101         TLSEXT_TYPE_session_ticket,
 102         NULL,
 103         tls_parse_client_session_ticket,
 104         tls_parse_server_session_ticket,
 105         tls_construct_server_session_ticket,
 106         tls_construct_client_session_ticket,
 107         NULL,
 108         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
 109     },
 110     {
 111         TLSEXT_TYPE_signature_algorithms,
 112         NULL,
 113         tls_parse_client_sig_algs,
 114         NULL,
 115         NULL,
 116         tls_construct_client_sig_algs,
 117         NULL,
 118         EXT_CLIENT_HELLO
 119     },
 120 #ifndef OPENSSL_NO_OCSP
 121     {
 122         TLSEXT_TYPE_status_request,
 123         NULL,
 124         tls_parse_client_status_request,
 125         tls_parse_server_status_request,
 126         tls_construct_server_status_request,
 127         tls_construct_client_status_request,
 128         NULL,
 129         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 130         | EXT_TLS1_3_CERTIFICATE
 131     },
 132 #endif
 133 #ifndef OPENSSL_NO_NEXTPROTONEG
 134     {
 135         TLSEXT_TYPE_next_proto_neg,
 136         NULL,
 137         tls_parse_client_npn,
 138         tls_parse_server_npn,
 139         tls_construct_server_next_proto_neg,
 140         tls_construct_client_npn,
 141         NULL,
 142         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
 143     },
 144 #endif
 145     {
 146         TLSEXT_TYPE_application_layer_protocol_negotiation,
 147         NULL,
 148         tls_parse_client_alpn,
 149         tls_parse_server_alpn,
 150         tls_construct_server_alpn,
 151         tls_construct_client_alpn,
 152         NULL,
 153         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 154         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
 155     },
 156 #ifndef OPENSSL_NO_SRTP
 157     {
 158         TLSEXT_TYPE_use_srtp,
 159         NULL,
 160         tls_parse_client_use_srtp,
 161         tls_parse_server_use_srtp,
 162         tls_construct_server_use_srtp,
 163         tls_construct_client_use_srtp,
 164         NULL,
 165         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 166         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS | EXT_DTLS_ONLY
 167     },
 168 #endif
 169     {
 170         TLSEXT_TYPE_encrypt_then_mac,
 171         NULL,
 172         tls_parse_client_etm,
 173         tls_parse_server_etm,
 174         tls_construct_server_etm,
 175         tls_construct_client_etm,
 176         NULL,
 177         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
 178     },
 179 #ifndef OPENSSL_NO_CT
 180     {
 181         TLSEXT_TYPE_signed_certificate_timestamp,
 182         NULL,
 183         /*
 184          * No server side support for this, but can be provided by a custom
 185          * extension. This is an exception to the rule that custom extensions
 186          * cannot override built in ones.
 187          */
 188         NULL,
 189         tls_parse_server_sct,
 190         NULL,
 191         tls_construct_client_sct,
 192         NULL,
 193         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
 194         | EXT_TLS1_3_CERTIFICATE
 195     },
 196 #endif
 197     {
 198         TLSEXT_TYPE_extended_master_secret,
 199         NULL,
 200         tls_parse_client_ems,
 201         tls_parse_server_ems,
 202         tls_construct_server_ems,
 203         tls_construct_client_ems,
 204         NULL,
 205         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
 206     },
 207     {
 208         TLSEXT_TYPE_supported_versions,
 209         NULL,
 210         /* Processed inline as part of version selection */
 211         NULL,
 212         NULL,
 213         NULL,
 214         tls_construct_client_supported_versions,
 215         NULL,
 216         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY | EXT_TLS1_3_ONLY
 217     },
 218     {
 219         TLSEXT_TYPE_key_share,
 220         NULL,
 221         tls_parse_client_key_share,
 222         tls_parse_server_key_share,
 223         tls_construct_server_key_share,
 224         tls_construct_client_key_share,
 225         NULL,
 226         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO
 227         | EXT_TLS1_3_HELLO_RETRY_REQUEST | EXT_TLS_IMPLEMENTATION_ONLY
 228         | EXT_TLS1_3_ONLY
 229     },
 230     {
 231         /*
 232          * Special unsolicited ServerHello extension only used when
 233          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set
 234          */
 235         TLSEXT_TYPE_cryptopro_bug,
 236         NULL,
 237         NULL,
 238         NULL,
 239         tls_construct_server_cryptopro_bug,
 240         NULL,
 241         NULL,
 242         EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY
 243     },
 244     {
 245         /* Last in the list because it must be added as the last extension */
 246         TLSEXT_TYPE_padding,
 247         NULL,
 248         /* We send this, but don't read it */
 249         NULL,
 250         NULL,
 251         NULL,
 252         tls_construct_client_padding,
 253         NULL,
 254         EXT_CLIENT_HELLO
 255     }
 256 };
 257
 258 /*
 259  * Comparison function used in a call to qsort (see tls_collect_extensions()
 260  * below.)
 261  * The two arguments |p1| and |p2| are expected to be pointers to RAW_EXTENSIONs
 262  *
 263  * Returns:
 264  *  1 if the type for p1 is greater than p2
 265  *  0 if the type for p1 and p2 are the same
 266  * -1 if the type for p1 is less than p2
 267  */
 268 static int compare_extensions(const void *p1, const void *p2)
 269 {
 270     const RAW_EXTENSION *e1 = (const RAW_EXTENSION *)p1;
 271     const RAW_EXTENSION *e2 = (const RAW_EXTENSION *)p2;
 272
 273     if (e1->type < e2->type)
 274         return -1;
 275     else if (e1->type > e2->type)
 276         return 1;
 277
 278     return 0;
 279 }
 280
 281 /*
 282  * Verify whether we are allowed to use the extension |type| in the current
 283  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
 284  * indicate the extension is not allowed.
 285  */
 286 static int verify_extension(SSL *s, unsigned int context, unsigned int type)
 287 {
 288     size_t i;
 289
 290     for (i = 0; i < OSSL_NELEM(ext_defs); i++) {
 291         if (type == ext_defs[i].type) {
 292             /* Check we're allowed to use this extension in this context */
 293             if ((context & ext_defs[i].context) == 0)
 294                 return 0;
 295
 296             if (SSL_IS_DTLS(s)) {
 297                 if ((ext_defs[i].context & EXT_TLS_ONLY) != 0)
 298                     return 0;
 299             } else if ((ext_defs[i].context & EXT_DTLS_ONLY) != 0) {
 300                     return 0;
 301             }
 302
 303             return 1;
 304         }
 305     }
 306
 307     /* Unknown extension. We allow it */
 308     return 1;
 309 }
 310
 311 /*
 312  * Finds an extension definition for the give extension |type|.
 313  * Returns 1 if found and stores the definition in |*def|, or returns 0
 314  * otherwise.
 315  */
 316 static int find_extension_definition(SSL *s, unsigned int type,
 317                                      const EXTENSION_DEFINITION **def)
 318 {
 319     size_t i;
 320
 321     for (i = 0; i < OSSL_NELEM(ext_defs); i++) {
 322         if (type == ext_defs[i].type) {
 323             *def = &ext_defs[i];
 324             return 1;
 325         }
 326     }
 327
 328     /* Unknown extension */
 329     return 0;
 330 }
 331
 332 /*
 333  * Gather a list of all the extensions from the data in |packet]. |context|
 334  * tells us which message this extension is for. Ttls_parse_server_ec_pt_formatshe raw extension data is
 335  * stored in |*res| with the number of found extensions in |*numfound|. In the
 336  * event of an error the alert type to use is stored in |*ad|. We don't actually
 337  * process the content of the extensions yet, except to check their types.
 338  *
 339  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
 340  * more than one extension of the same type in a ClientHello or ServerHello.
 341  * This function returns 1 if all extensions are unique and we have parsed their
 342  * types, and 0 if the extensions contain duplicates, could not be successfully
 343  * parsed, or an internal error occurred.
 344  */
 345
 346 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
 347                            RAW_EXTENSION **res, size_t *numfound, int *ad)
 348 {
 349     PACKET extensions = *packet;
 350     size_t num_extensions = 0, i = 0;
 351     RAW_EXTENSION *raw_extensions = NULL;
 352
 353     /* First pass: count the extensions. */
 354     while (PACKET_remaining(&extensions) > 0) {
 355         unsigned int type;
 356         PACKET extension;
 357
 358         if (!PACKET_get_net_2(&extensions, &type) ||
 359             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
 360             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 361             *ad = SSL_AD_DECODE_ERROR;
 362             goto err;
 363         }
 364         /* Verify this extension is allowed */
 365         if (!verify_extension(s, context, type)) {
 366             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
 367             *ad = SSL_AD_ILLEGAL_PARAMETER;
 368             goto err;
 369         }
 370         num_extensions++;
 371     }
 372
 373     if (num_extensions > 0) {
 374         raw_extensions = OPENSSL_zalloc(sizeof(*raw_extensions)
 375                                         * num_extensions);
 376         if (raw_extensions == NULL) {
 377             *ad = SSL_AD_INTERNAL_ERROR;
 378             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
 379             goto err;
 380         }
 381
 382         /* Second pass: collect the extensions. */
 383         for (i = 0; i < num_extensions; i++) {
 384             if (!PACKET_get_net_2(packet, &raw_extensions[i].type) ||
 385                 !PACKET_get_length_prefixed_2(packet,
 386                                               &raw_extensions[i].data)) {
 387                 /* This should not happen. */
 388                 *ad = SSL_AD_INTERNAL_ERROR;
 389                 SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 390                 goto err;
 391             }
 392         }
 393
 394         if (PACKET_remaining(packet) != 0) {
 395             *ad = SSL_AD_DECODE_ERROR;
 396             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_LENGTH_MISMATCH);
 397             goto err;
 398         }
 399         /* Sort the extensions and make sure there are no duplicates. */
 400         qsort(raw_extensions, num_extensions, sizeof(*raw_extensions),
 401               compare_extensions);
 402         for (i = 1; i < num_extensions; i++) {
 403             if (raw_extensions[i - 1].type == raw_extensions[i].type) {
 404                 *ad = SSL_AD_DECODE_ERROR;
 405                 goto err;
 406             }
 407         }
 408     }
 409
 410     /*
 411      * Initialise all known extensions relevant to this context, whether we have
 412      * found them or not
 413      */
 414     for (i = 0; i < OSSL_NELEM(ext_defs); i++) {
 415         if(ext_defs[i].init_ext != NULL && (ext_defs[i].context & context) != 0
 416                 && !ext_defs[i].init_ext(s, context)) {
 417             *ad = SSL_AD_INTERNAL_ERROR;
 418             goto err;
 419         }
 420     }
 421
 422     *res = raw_extensions;
 423     *numfound = num_extensions;
 424     return 1;
 425
 426  err:
 427     OPENSSL_free(raw_extensions);
 428     return 0;
 429 }
 430
 431 /*
 432  * Parse all remaining extensions that have not yet been parsed. Also calls the
 433  * finalisation for all extensions at the end. Returns 1 for success or 0 for
 434  * failure. On failure, |*al| is populated with a suitable alert code.
 435  */
 436 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts,
 437                              size_t numexts, int *al)
 438 {
 439     size_t loop;
 440
 441     for (loop = 0; loop < numexts; loop++) {
 442         RAW_EXTENSION *currext = &exts[loop];
 443         const EXTENSION_DEFINITION *extdef = NULL;
 444         int (*parser)(SSL *s, PACKET *pkt, int *al) = NULL;
 445
 446         if (s->tlsext_debug_cb)
 447             s->tlsext_debug_cb(s, !s->server, currext->type,
 448                                PACKET_data(&currext->data),
 449                                PACKET_remaining(&currext->data),
 450                                s->tlsext_debug_arg);
 451
 452         /* Skip if we've already parsed this extension */
 453         if (currext->parsed)
 454             continue;
 455
 456         currext->parsed = 1;
 457
 458         parser = NULL;
 459         if (find_extension_definition(s, currext->type, &extdef)) {
 460             parser = s->server ? extdef->parse_client_ext
 461                                : extdef->parse_server_ext;
 462
 463             /* Check if extension is defined for our protocol. If not, skip */
 464             if ((SSL_IS_DTLS(s)
 465                         && (extdef->context & EXT_TLS_IMPLEMENTATION_ONLY) != 0)
 466                     || (s->version == SSL3_VERSION
 467                             && (extdef->context & EXT_SSL3_ALLOWED) == 0)
 468                     || (SSL_IS_TLS13(s)
 469                         && (extdef->context & EXT_TLS1_2_AND_BELOW_ONLY) != 0)
 470                     || (!SSL_IS_TLS13(s)
 471                         && (extdef->context & EXT_TLS1_3_ONLY) != 0))
 472                 continue;
 473         }
 474
 475         if (parser == NULL) {
 476             /*
 477              * Could be a custom extension. We only allow this if it is a non
 478              * resumed session on the server side.
 479              *
 480              * TODO(TLS1.3): We only allow old style <=TLS1.2 custom extensions.
 481              * We're going to need a new mechanism for TLS1.3 to specify which
 482              * messages to add the custom extensions to.
 483              */
 484             if ((!s->hit || !s->server)
 485                     && (context
 486                         & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 487                     && custom_ext_parse(s, s->server, currext->type,
 488                                         PACKET_data(&currext->data),
 489                                         PACKET_remaining(&currext->data),
 490                                         al) <= 0)
 491                 return 0;
 492
 493             continue;
 494         }
 495
 496         if (!parser(s, &currext->data, al))
 497             return 0;
 498     }
 499
 500     /*
 501      * Finalise all known extensions relevant to this context, whether we have
 502      * found them or not
 503      */
 504     for (loop = 0; loop < OSSL_NELEM(ext_defs); loop++) {
 505         if(ext_defs[loop].finalise_ext != NULL
 506                 && (ext_defs[loop].context & context) != 0
 507                 && !ext_defs[loop].finalise_ext(s, context)) {
 508             *al = SSL_AD_INTERNAL_ERROR;
 509             return 0;
 510         }
 511     }
 512
 513     return 1;
 514 }
 515
 516 /*
 517  * Find a specific extension by |type| in the list |exts| containing |numexts|
 518  * extensions, and the parse it immediately. Returns 1 on success, or 0 on
 519  * failure. If a failure has occurred then |*al| will also be set to the alert
 520  * to be sent.
 521  */
 522 int tls_parse_extension(SSL *s, int type, int context, RAW_EXTENSION *exts,
 523                         size_t numexts, int *al)
 524 {
 525     RAW_EXTENSION *ext = tls_get_extension_by_type(exts, numexts, type);
 526
 527     if (ext == NULL)
 528         return 1;
 529
 530     return tls_parse_all_extensions(s, context, ext, 1, al);
 531 }
 532
 533 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
 534                              int *al)
 535 {
 536     size_t loop;
 537     int addcustom = 0;
 538     int min_version, max_version = 0, reason;
 539
 540     /*
 541      * Normally if something goes wrong during construction its an internal
 542      * error. We can always override this later.
 543      */
 544     *al = SSL_AD_INTERNAL_ERROR;
 545
 546     if (!WPACKET_start_sub_packet_u16(pkt)
 547                /*
 548                 * If extensions are of zero length then we don't even add the
 549                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
 550                 */
 551             || ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
 552                && s->version == SSL3_VERSION
 553                && !WPACKET_set_flags(pkt,
 554                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
 555         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 556         return 0;
 557     }
 558
 559     if ((context & EXT_CLIENT_HELLO) != 0) {
 560         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
 561         if (reason != 0) {
 562             SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, reason);
 563             return 0;
 564         }
 565     }
 566
 567     /* Add custom extensions first */
 568     if ((context & EXT_CLIENT_HELLO) != 0) {
 569         custom_ext_init(&s->cert->cli_ext);
 570         addcustom = 1;
 571     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
 572         /*
 573          * We already initialised the custom extensions during ClientHello
 574          * parsing.
 575          *
 576          * TODO(TLS1.3): We're going to need a new custom extension mechanism
 577          * for TLS1.3, so that custom extensions can specify which of the
 578          * multiple message they wish to add themselves to.
 579          */
 580         addcustom = 1;
 581     }
 582
 583     if (addcustom && !custom_ext_add(s, s->server, pkt, al)) {
 584         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 585         return 0;
 586     }
 587
 588     for (loop = 0; loop < OSSL_NELEM(ext_defs); loop++) {
 589         int (*construct)(SSL *s, WPACKET *pkt, int *al);
 590
 591         /* Skip if not relevant for our context */
 592         if ((ext_defs[loop].context & context) == 0)
 593             continue;
 594
 595         construct = s->server ? ext_defs[loop].construct_server_ext
 596                               : ext_defs[loop].construct_client_ext;
 597
 598         /* Check if this extension is defined for our protocol. If not, skip */
 599         if ((SSL_IS_DTLS(s)
 600                     && (ext_defs[loop].context & EXT_TLS_IMPLEMENTATION_ONLY)
 601                        != 0)
 602                 || (s->version == SSL3_VERSION
 603                         && (ext_defs[loop].context & EXT_SSL3_ALLOWED) == 0)
 604                 || (SSL_IS_TLS13(s)
 605                     && (ext_defs[loop].context & EXT_TLS1_2_AND_BELOW_ONLY)
 606                        != 0)
 607                 || (!SSL_IS_TLS13(s)
 608                     && (ext_defs[loop].context & EXT_TLS1_3_ONLY) != 0
 609                     && (context & EXT_CLIENT_HELLO) == 0)
 610                 || ((ext_defs[loop].context & EXT_TLS1_3_ONLY) != 0
 611                     && (context & EXT_CLIENT_HELLO) != 0
 612                     && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION))
 613                 || construct == NULL)
 614             continue;
 615
 616         if (!construct(s, pkt, al))
 617             return 0;
 618     }
 619
 620     if (!WPACKET_close(pkt)) {
 621         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
 622         return 0;
 623     }
 624
 625     return 1;
 626 }