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