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