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