Deprecated crypto-mdebug-backtrace
[openssl.git] / ssl / statem / extensions.c
1 /*
2  * Copyright 2016-2018 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (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 <string.h>
11 #include "internal/nelem.h"
12 #include "internal/cryptlib.h"
13 #include "../ssl_local.h"
14 #include "statem_local.h"
15 #include "internal/cryptlib.h"
16
17 static int final_renegotiate(SSL *s, unsigned int context, int sent);
18 static int init_server_name(SSL *s, unsigned int context);
19 static int final_server_name(SSL *s, unsigned int context, int sent);
20 #ifndef OPENSSL_NO_EC
21 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent);
22 #endif
23 static int init_session_ticket(SSL *s, unsigned int context);
24 #ifndef OPENSSL_NO_OCSP
25 static int init_status_request(SSL *s, unsigned int context);
26 #endif
27 #ifndef OPENSSL_NO_NEXTPROTONEG
28 static int init_npn(SSL *s, unsigned int context);
29 #endif
30 static int init_alpn(SSL *s, unsigned int context);
31 static int final_alpn(SSL *s, unsigned int context, int sent);
32 static int init_sig_algs_cert(SSL *s, unsigned int context);
33 static int init_sig_algs(SSL *s, unsigned int context);
34 static int init_certificate_authorities(SSL *s, unsigned int context);
35 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
36                                                         unsigned int context,
37                                                         X509 *x,
38                                                         size_t chainidx);
39 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
40                                              unsigned int context, X509 *x,
41                                              size_t chainidx);
42 #ifndef OPENSSL_NO_SRP
43 static int init_srp(SSL *s, unsigned int context);
44 #endif
45 static int init_etm(SSL *s, unsigned int context);
46 static int init_ems(SSL *s, unsigned int context);
47 static int final_ems(SSL *s, unsigned int context, int sent);
48 static int init_psk_kex_modes(SSL *s, unsigned int context);
49 static int final_key_share(SSL *s, unsigned int context, int sent);
50 #ifndef OPENSSL_NO_SRTP
51 static int init_srtp(SSL *s, unsigned int context);
52 #endif
53 static int final_sig_algs(SSL *s, unsigned int context, int sent);
54 static int final_early_data(SSL *s, unsigned int context, int sent);
55 static int final_maxfragmentlen(SSL *s, unsigned int context, int sent);
56 static int init_post_handshake_auth(SSL *s, unsigned int context);
57
58 /* Structure to define a built-in extension */
59 typedef struct extensions_definition_st {
60     /* The defined type for the extension */
61     unsigned int type;
62     /*
63      * The context that this extension applies to, e.g. what messages and
64      * protocol versions
65      */
66     unsigned int context;
67     /*
68      * Initialise extension before parsing. Always called for relevant contexts
69      * even if extension not present
70      */
71     int (*init)(SSL *s, unsigned int context);
72     /* Parse extension sent from client to server */
73     int (*parse_ctos)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
74                       size_t chainidx);
75     /* Parse extension send from server to client */
76     int (*parse_stoc)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
77                       size_t chainidx);
78     /* Construct extension sent from server to client */
79     EXT_RETURN (*construct_stoc)(SSL *s, WPACKET *pkt, unsigned int context,
80                                  X509 *x, size_t chainidx);
81     /* Construct extension sent from client to server */
82     EXT_RETURN (*construct_ctos)(SSL *s, WPACKET *pkt, unsigned int context,
83                                  X509 *x, size_t chainidx);
84     /*
85      * Finalise extension after parsing. Always called where an extensions was
86      * initialised even if the extension was not present. |sent| is set to 1 if
87      * the extension was seen, or 0 otherwise.
88      */
89     int (*final)(SSL *s, unsigned int context, int sent);
90 } EXTENSION_DEFINITION;
91
92 /*
93  * Definitions of all built-in extensions. NOTE: Changes in the number or order
94  * of these extensions should be mirrored with equivalent changes to the
95  * indexes ( TLSEXT_IDX_* ) defined in ssl_local.h.
96  * Each extension has an initialiser, a client and
97  * server side parser and a finaliser. The initialiser is called (if the
98  * extension is relevant to the given context) even if we did not see the
99  * extension in the message that we received. The parser functions are only
100  * called if we see the extension in the message. The finalisers are always
101  * called if the initialiser was called.
102  * There are also server and client side constructor functions which are always
103  * called during message construction if the extension is relevant for the
104  * given context.
105  * The initialisation, parsing, finalisation and construction functions are
106  * always called in the order defined in this list. Some extensions may depend
107  * on others having been processed first, so the order of this list is
108  * significant.
109  * The extension context is defined by a series of flags which specify which
110  * messages the extension is relevant to. These flags also specify whether the
111  * extension is relevant to a particular protocol or protocol version.
112  *
113  * TODO(TLS1.3): Make sure we have a test to check the consistency of these
114  *
115  * NOTE: WebSphere Application Server 7+ cannot handle empty extensions at
116  * the end, keep these extensions before signature_algorithm.
117  */
118 #define INVALID_EXTENSION { 0x10000, 0, NULL, NULL, NULL, NULL, NULL, NULL }
119 static const EXTENSION_DEFINITION ext_defs[] = {
120     {
121         TLSEXT_TYPE_renegotiate,
122         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
123         | SSL_EXT_SSL3_ALLOWED | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
124         NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate,
125         tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate,
126         final_renegotiate
127     },
128     {
129         TLSEXT_TYPE_server_name,
130         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
131         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
132         init_server_name,
133         tls_parse_ctos_server_name, tls_parse_stoc_server_name,
134         tls_construct_stoc_server_name, tls_construct_ctos_server_name,
135         final_server_name
136     },
137     {
138         TLSEXT_TYPE_max_fragment_length,
139         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
140         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
141         NULL, tls_parse_ctos_maxfragmentlen, tls_parse_stoc_maxfragmentlen,
142         tls_construct_stoc_maxfragmentlen, tls_construct_ctos_maxfragmentlen,
143         final_maxfragmentlen
144     },
145 #ifndef OPENSSL_NO_SRP
146     {
147         TLSEXT_TYPE_srp,
148         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
149         init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL
150     },
151 #else
152     INVALID_EXTENSION,
153 #endif
154 #ifndef OPENSSL_NO_EC
155     {
156         TLSEXT_TYPE_ec_point_formats,
157         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
158         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
159         NULL, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats,
160         tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats,
161         final_ec_pt_formats
162     },
163 #else
164     INVALID_EXTENSION,
165 #endif
166 #if !defined(OPENSSL_NO_EC) || !defined(OPENSSL_NO_DH)
167     {
168         /*
169          * "supported_groups" is spread across several specifications.
170          * It was originally specified as "elliptic_curves" in RFC 4492,
171          * and broadened to include named FFDH groups by RFC 7919.
172          * Both RFCs 4492 and 7919 do not include a provision for the server
173          * to indicate to the client the complete list of groups supported
174          * by the server, with the server instead just indicating the
175          * selected group for this connection in the ServerKeyExchange
176          * message.  TLS 1.3 adds a scheme for the server to indicate
177          * to the client its list of supported groups in the
178          * EncryptedExtensions message, but none of the relevant
179          * specifications permit sending supported_groups in the ServerHello.
180          * Nonetheless (possibly due to the close proximity to the
181          * "ec_point_formats" extension, which is allowed in the ServerHello),
182          * there are several servers that send this extension in the
183          * ServerHello anyway.  Up to and including the 1.1.0 release,
184          * we did not check for the presence of nonpermitted extensions,
185          * so to avoid a regression, we must permit this extension in the
186          * TLS 1.2 ServerHello as well.
187          *
188          * Note that there is no tls_parse_stoc_supported_groups function,
189          * so we do not perform any additional parsing, validation, or
190          * processing on the server's group list -- this is just a minimal
191          * change to preserve compatibility with these misbehaving servers.
192          */
193         TLSEXT_TYPE_supported_groups,
194         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
195         | SSL_EXT_TLS1_2_SERVER_HELLO,
196         NULL, tls_parse_ctos_supported_groups, NULL,
197         tls_construct_stoc_supported_groups,
198         tls_construct_ctos_supported_groups, NULL
199     },
200 #else
201     INVALID_EXTENSION,
202 #endif
203     {
204         TLSEXT_TYPE_session_ticket,
205         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
206         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
207         init_session_ticket, tls_parse_ctos_session_ticket,
208         tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket,
209         tls_construct_ctos_session_ticket, NULL
210     },
211 #ifndef OPENSSL_NO_OCSP
212     {
213         TLSEXT_TYPE_status_request,
214         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
215         | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
216         init_status_request, tls_parse_ctos_status_request,
217         tls_parse_stoc_status_request, tls_construct_stoc_status_request,
218         tls_construct_ctos_status_request, NULL
219     },
220 #else
221     INVALID_EXTENSION,
222 #endif
223 #ifndef OPENSSL_NO_NEXTPROTONEG
224     {
225         TLSEXT_TYPE_next_proto_neg,
226         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
227         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
228         init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn,
229         tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL
230     },
231 #else
232     INVALID_EXTENSION,
233 #endif
234     {
235         /*
236          * Must appear in this list after server_name so that finalisation
237          * happens after server_name callbacks
238          */
239         TLSEXT_TYPE_application_layer_protocol_negotiation,
240         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
241         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
242         init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn,
243         tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn
244     },
245 #ifndef OPENSSL_NO_SRTP
246     {
247         TLSEXT_TYPE_use_srtp,
248         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
249         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_DTLS_ONLY,
250         init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp,
251         tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL
252     },
253 #else
254     INVALID_EXTENSION,
255 #endif
256     {
257         TLSEXT_TYPE_encrypt_then_mac,
258         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
259         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
260         init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm,
261         tls_construct_stoc_etm, tls_construct_ctos_etm, NULL
262     },
263 #ifndef OPENSSL_NO_CT
264     {
265         TLSEXT_TYPE_signed_certificate_timestamp,
266         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
267         | SSL_EXT_TLS1_3_CERTIFICATE | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
268         NULL,
269         /*
270          * No server side support for this, but can be provided by a custom
271          * extension. This is an exception to the rule that custom extensions
272          * cannot override built in ones.
273          */
274         NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct,  NULL
275     },
276 #else
277     INVALID_EXTENSION,
278 #endif
279     {
280         TLSEXT_TYPE_extended_master_secret,
281         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
282         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
283         init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems,
284         tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems
285     },
286     {
287         TLSEXT_TYPE_signature_algorithms_cert,
288         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
289         init_sig_algs_cert, tls_parse_ctos_sig_algs_cert,
290         tls_parse_ctos_sig_algs_cert,
291         /* We do not generate signature_algorithms_cert at present. */
292         NULL, NULL, NULL
293     },
294     {
295         TLSEXT_TYPE_post_handshake_auth,
296         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ONLY,
297         init_post_handshake_auth,
298         tls_parse_ctos_post_handshake_auth, NULL,
299         NULL, tls_construct_ctos_post_handshake_auth,
300         NULL,
301     },
302     {
303         TLSEXT_TYPE_signature_algorithms,
304         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
305         init_sig_algs, tls_parse_ctos_sig_algs,
306         tls_parse_ctos_sig_algs, tls_construct_ctos_sig_algs,
307         tls_construct_ctos_sig_algs, final_sig_algs
308     },
309     {
310         TLSEXT_TYPE_supported_versions,
311         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
312         | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY,
313         NULL,
314         /* Processed inline as part of version selection */
315         NULL, tls_parse_stoc_supported_versions,
316         tls_construct_stoc_supported_versions,
317         tls_construct_ctos_supported_versions, NULL
318     },
319     {
320         TLSEXT_TYPE_psk_kex_modes,
321         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY
322         | SSL_EXT_TLS1_3_ONLY,
323         init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL,
324         tls_construct_ctos_psk_kex_modes, NULL
325     },
326     {
327         /*
328          * Must be in this list after supported_groups. We need that to have
329          * been parsed before we do this one.
330          */
331         TLSEXT_TYPE_key_share,
332         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
333         | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY
334         | SSL_EXT_TLS1_3_ONLY,
335         NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share,
336         tls_construct_stoc_key_share, tls_construct_ctos_key_share,
337         final_key_share
338     },
339     {
340         /* Must be after key_share */
341         TLSEXT_TYPE_cookie,
342         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
343         | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
344         NULL, tls_parse_ctos_cookie, tls_parse_stoc_cookie,
345         tls_construct_stoc_cookie, tls_construct_ctos_cookie, NULL
346     },
347     {
348         /*
349          * Special unsolicited ServerHello extension only used when
350          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set. We allow it in a ClientHello but
351          * ignore it.
352          */
353         TLSEXT_TYPE_cryptopro_bug,
354         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
355         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
356         NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
357     },
358     {
359         TLSEXT_TYPE_early_data,
360         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
361         | SSL_EXT_TLS1_3_NEW_SESSION_TICKET | SSL_EXT_TLS1_3_ONLY,
362         NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data,
363         tls_construct_stoc_early_data, tls_construct_ctos_early_data,
364         final_early_data
365     },
366     {
367         TLSEXT_TYPE_certificate_authorities,
368         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
369         | SSL_EXT_TLS1_3_ONLY,
370         init_certificate_authorities,
371         tls_parse_certificate_authorities, tls_parse_certificate_authorities,
372         tls_construct_certificate_authorities,
373         tls_construct_certificate_authorities, NULL,
374     },
375     {
376         /* Must be immediately before pre_shared_key */
377         TLSEXT_TYPE_padding,
378         SSL_EXT_CLIENT_HELLO,
379         NULL,
380         /* We send this, but don't read it */
381         NULL, NULL, NULL, tls_construct_ctos_padding, NULL
382     },
383     {
384         /* Required by the TLSv1.3 spec to always be the last extension */
385         TLSEXT_TYPE_psk,
386         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
387         | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
388         NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk,
389         tls_construct_ctos_psk, NULL
390     }
391 };
392
393 /* Check whether an extension's context matches the current context */
394 static int validate_context(SSL *s, unsigned int extctx, unsigned int thisctx)
395 {
396     /* Check we're allowed to use this extension in this context */
397     if ((thisctx & extctx) == 0)
398         return 0;
399
400     if (SSL_IS_DTLS(s)) {
401         if ((extctx & SSL_EXT_TLS_ONLY) != 0)
402             return 0;
403     } else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) {
404         return 0;
405     }
406
407     return 1;
408 }
409
410 int tls_validate_all_contexts(SSL *s, unsigned int thisctx, RAW_EXTENSION *exts)
411 {
412     size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset;
413     RAW_EXTENSION *thisext;
414     unsigned int context;
415     ENDPOINT role = ENDPOINT_BOTH;
416
417     if ((thisctx & SSL_EXT_CLIENT_HELLO) != 0)
418         role = ENDPOINT_SERVER;
419     else if ((thisctx & SSL_EXT_TLS1_2_SERVER_HELLO) != 0)
420         role = ENDPOINT_CLIENT;
421
422     /* Calculate the number of extensions in the extensions list */
423     num_exts = builtin_num + s->cert->custext.meths_count;
424
425     for (thisext = exts, i = 0; i < num_exts; i++, thisext++) {
426         if (!thisext->present)
427             continue;
428
429         if (i < builtin_num) {
430             context = ext_defs[i].context;
431         } else {
432             custom_ext_method *meth = NULL;
433
434             meth = custom_ext_find(&s->cert->custext, role, thisext->type,
435                                    &offset);
436             if (!ossl_assert(meth != NULL))
437                 return 0;
438             context = meth->context;
439         }
440
441         if (!validate_context(s, context, thisctx))
442             return 0;
443     }
444
445     return 1;
446 }
447
448 /*
449  * Verify whether we are allowed to use the extension |type| in the current
450  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
451  * indicate the extension is not allowed. If returning 1 then |*found| is set to
452  * the definition for the extension we found.
453  */
454 static int verify_extension(SSL *s, unsigned int context, unsigned int type,
455                             custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
456                             RAW_EXTENSION **found)
457 {
458     size_t i;
459     size_t builtin_num = OSSL_NELEM(ext_defs);
460     const EXTENSION_DEFINITION *thisext;
461
462     for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) {
463         if (type == thisext->type) {
464             if (!validate_context(s, thisext->context, context))
465                 return 0;
466
467             *found = &rawexlist[i];
468             return 1;
469         }
470     }
471
472     /* Check the custom extensions */
473     if (meths != NULL) {
474         size_t offset = 0;
475         ENDPOINT role = ENDPOINT_BOTH;
476         custom_ext_method *meth = NULL;
477
478         if ((context & SSL_EXT_CLIENT_HELLO) != 0)
479             role = ENDPOINT_SERVER;
480         else if ((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0)
481             role = ENDPOINT_CLIENT;
482
483         meth = custom_ext_find(meths, role, type, &offset);
484         if (meth != NULL) {
485             if (!validate_context(s, meth->context, context))
486                 return 0;
487             *found = &rawexlist[offset + builtin_num];
488             return 1;
489         }
490     }
491
492     /* Unknown extension. We allow it */
493     *found = NULL;
494     return 1;
495 }
496
497 /*
498  * Check whether the context defined for an extension |extctx| means whether
499  * the extension is relevant for the current context |thisctx| or not. Returns
500  * 1 if the extension is relevant for this context, and 0 otherwise
501  */
502 int extension_is_relevant(SSL *s, unsigned int extctx, unsigned int thisctx)
503 {
504     int is_tls13;
505
506     /*
507      * For HRR we haven't selected the version yet but we know it will be
508      * TLSv1.3
509      */
510     if ((thisctx & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
511         is_tls13 = 1;
512     else
513         is_tls13 = SSL_IS_TLS13(s);
514
515     if ((SSL_IS_DTLS(s)
516                 && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
517             || (s->version == SSL3_VERSION
518                     && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
519             /*
520              * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated",
521              * which is never true when generating the ClientHello.
522              * However, version negotiation *has* occurred by the time the
523              * ClientHello extensions are being parsed.
524              * Be careful to allow TLS 1.3-only extensions when generating
525              * the ClientHello.
526              */
527             || (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
528             || (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0
529                 && (thisctx & SSL_EXT_CLIENT_HELLO) == 0)
530             || (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0)
531             || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0))
532         return 0;
533     return 1;
534 }
535
536 /*
537  * Gather a list of all the extensions from the data in |packet]. |context|
538  * tells us which message this extension is for. The raw extension data is
539  * stored in |*res| on success. We don't actually process the content of the
540  * extensions yet, except to check their types. This function also runs the
541  * initialiser functions for all known extensions if |init| is nonzero (whether
542  * we have collected them or not). If successful the caller is responsible for
543  * freeing the contents of |*res|.
544  *
545  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
546  * more than one extension of the same type in a ClientHello or ServerHello.
547  * This function returns 1 if all extensions are unique and we have parsed their
548  * types, and 0 if the extensions contain duplicates, could not be successfully
549  * found, or an internal error occurred. We only check duplicates for
550  * extensions that we know about. We ignore others.
551  */
552 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
553                            RAW_EXTENSION **res, size_t *len, int init)
554 {
555     PACKET extensions = *packet;
556     size_t i = 0;
557     size_t num_exts;
558     custom_ext_methods *exts = &s->cert->custext;
559     RAW_EXTENSION *raw_extensions = NULL;
560     const EXTENSION_DEFINITION *thisexd;
561
562     *res = NULL;
563
564     /*
565      * Initialise server side custom extensions. Client side is done during
566      * construction of extensions for the ClientHello.
567      */
568     if ((context & SSL_EXT_CLIENT_HELLO) != 0)
569         custom_ext_init(&s->cert->custext);
570
571     num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0);
572     raw_extensions = OPENSSL_zalloc(num_exts * sizeof(*raw_extensions));
573     if (raw_extensions == NULL) {
574         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_COLLECT_EXTENSIONS,
575                  ERR_R_MALLOC_FAILURE);
576         return 0;
577     }
578
579     i = 0;
580     while (PACKET_remaining(&extensions) > 0) {
581         unsigned int type, idx;
582         PACKET extension;
583         RAW_EXTENSION *thisex;
584
585         if (!PACKET_get_net_2(&extensions, &type) ||
586             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
587             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_COLLECT_EXTENSIONS,
588                      SSL_R_BAD_EXTENSION);
589             goto err;
590         }
591         /*
592          * Verify this extension is allowed. We only check duplicates for
593          * extensions that we recognise. We also have a special case for the
594          * PSK extension, which must be the last one in the ClientHello.
595          */
596         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
597                 || (thisex != NULL && thisex->present == 1)
598                 || (type == TLSEXT_TYPE_psk
599                     && (context & SSL_EXT_CLIENT_HELLO) != 0
600                     && PACKET_remaining(&extensions) != 0)) {
601             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_COLLECT_EXTENSIONS,
602                      SSL_R_BAD_EXTENSION);
603             goto err;
604         }
605         idx = thisex - raw_extensions;
606         /*-
607          * Check that we requested this extension (if appropriate). Requests can
608          * be sent in the ClientHello and CertificateRequest. Unsolicited
609          * extensions can be sent in the NewSessionTicket. We only do this for
610          * the built-in extensions. Custom extensions have a different but
611          * similar check elsewhere.
612          * Special cases:
613          * - The HRR cookie extension is unsolicited
614          * - The renegotiate extension is unsolicited (the client signals
615          *   support via an SCSV)
616          * - The signed_certificate_timestamp extension can be provided by a
617          * custom extension or by the built-in version. We let the extension
618          * itself handle unsolicited response checks.
619          */
620         if (idx < OSSL_NELEM(ext_defs)
621                 && (context & (SSL_EXT_CLIENT_HELLO
622                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
623                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0
624                 && type != TLSEXT_TYPE_cookie
625                 && type != TLSEXT_TYPE_renegotiate
626                 && type != TLSEXT_TYPE_signed_certificate_timestamp
627                 && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0
628 #ifndef OPENSSL_NO_GOST
629                 && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
630                      && type == TLSEXT_TYPE_cryptopro_bug)
631 #endif
632                                                                 ) {
633             SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION,
634                      SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_UNSOLICITED_EXTENSION);
635             goto err;
636         }
637         if (thisex != NULL) {
638             thisex->data = extension;
639             thisex->present = 1;
640             thisex->type = type;
641             thisex->received_order = i++;
642             if (s->ext.debug_cb)
643                 s->ext.debug_cb(s, !s->server, thisex->type,
644                                 PACKET_data(&thisex->data),
645                                 PACKET_remaining(&thisex->data),
646                                 s->ext.debug_arg);
647         }
648     }
649
650     if (init) {
651         /*
652          * Initialise all known extensions relevant to this context,
653          * whether we have found them or not
654          */
655         for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs);
656              i++, thisexd++) {
657             if (thisexd->init != NULL && (thisexd->context & context) != 0
658                 && extension_is_relevant(s, thisexd->context, context)
659                 && !thisexd->init(s, context)) {
660                 /* SSLfatal() already called */
661                 goto err;
662             }
663         }
664     }
665
666     *res = raw_extensions;
667     if (len != NULL)
668         *len = num_exts;
669     return 1;
670
671  err:
672     OPENSSL_free(raw_extensions);
673     return 0;
674 }
675
676 /*
677  * Runs the parser for a given extension with index |idx|. |exts| contains the
678  * list of all parsed extensions previously collected by
679  * tls_collect_extensions(). The parser is only run if it is applicable for the
680  * given |context| and the parser has not already been run. If this is for a
681  * Certificate message, then we also provide the parser with the relevant
682  * Certificate |x| and its position in the |chainidx| with 0 being the first
683  * Certificate. Returns 1 on success or 0 on failure. If an extension is not
684  * present this counted as success.
685  */
686 int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
687                         RAW_EXTENSION *exts, X509 *x, size_t chainidx)
688 {
689     RAW_EXTENSION *currext = &exts[idx];
690     int (*parser)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
691                   size_t chainidx) = NULL;
692
693     /* Skip if the extension is not present */
694     if (!currext->present)
695         return 1;
696
697     /* Skip if we've already parsed this extension */
698     if (currext->parsed)
699         return 1;
700
701     currext->parsed = 1;
702
703     if (idx < OSSL_NELEM(ext_defs)) {
704         /* We are handling a built-in extension */
705         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
706
707         /* Check if extension is defined for our protocol. If not, skip */
708         if (!extension_is_relevant(s, extdef->context, context))
709             return 1;
710
711         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
712
713         if (parser != NULL)
714             return parser(s, &currext->data, context, x, chainidx);
715
716         /*
717          * If the parser is NULL we fall through to the custom extension
718          * processing
719          */
720     }
721
722     /* Parse custom extensions */
723     return custom_ext_parse(s, context, currext->type,
724                             PACKET_data(&currext->data),
725                             PACKET_remaining(&currext->data),
726                             x, chainidx);
727 }
728
729 /*
730  * Parse all remaining extensions that have not yet been parsed. Also calls the
731  * finalisation for all extensions at the end if |fin| is nonzero, whether we
732  * collected them or not. Returns 1 for success or 0 for failure. If we are
733  * working on a Certificate message then we also pass the Certificate |x| and
734  * its position in the |chainidx|, with 0 being the first certificate.
735  */
736 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, X509 *x,
737                              size_t chainidx, int fin)
738 {
739     size_t i, numexts = OSSL_NELEM(ext_defs);
740     const EXTENSION_DEFINITION *thisexd;
741
742     /* Calculate the number of extensions in the extensions list */
743     numexts += s->cert->custext.meths_count;
744
745     /* Parse each extension in turn */
746     for (i = 0; i < numexts; i++) {
747         if (!tls_parse_extension(s, i, context, exts, x, chainidx)) {
748             /* SSLfatal() already called */
749             return 0;
750         }
751     }
752
753     if (fin) {
754         /*
755          * Finalise all known extensions relevant to this context,
756          * whether we have found them or not
757          */
758         for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs);
759              i++, thisexd++) {
760             if (thisexd->final != NULL && (thisexd->context & context) != 0
761                 && !thisexd->final(s, context, exts[i].present)) {
762                 /* SSLfatal() already called */
763                 return 0;
764             }
765         }
766     }
767
768     return 1;
769 }
770
771 int should_add_extension(SSL *s, unsigned int extctx, unsigned int thisctx,
772                          int max_version)
773 {
774     /* Skip if not relevant for our context */
775     if ((extctx & thisctx) == 0)
776         return 0;
777
778     /* Check if this extension is defined for our protocol. If not, skip */
779     if (!extension_is_relevant(s, extctx, thisctx)
780             || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
781                 && (thisctx & SSL_EXT_CLIENT_HELLO) != 0
782                 && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
783         return 0;
784
785     return 1;
786 }
787
788 /*
789  * Construct all the extensions relevant to the current |context| and write
790  * them to |pkt|. If this is an extension for a Certificate in a Certificate
791  * message, then |x| will be set to the Certificate we are handling, and
792  * |chainidx| will indicate the position in the chainidx we are processing (with
793  * 0 being the first in the chain). Returns 1 on success or 0 on failure. On a
794  * failure construction stops at the first extension to fail to construct.
795  */
796 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
797                              X509 *x, size_t chainidx)
798 {
799     size_t i;
800     int min_version, max_version = 0, reason;
801     const EXTENSION_DEFINITION *thisexd;
802
803     if (!WPACKET_start_sub_packet_u16(pkt)
804                /*
805                 * If extensions are of zero length then we don't even add the
806                 * extensions length bytes to a ClientHello/ServerHello
807                 * (for non-TLSv1.3).
808                 */
809             || ((context &
810                  (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0
811                 && !WPACKET_set_flags(pkt,
812                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
813         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
814                  ERR_R_INTERNAL_ERROR);
815         return 0;
816     }
817
818     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
819         reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL);
820         if (reason != 0) {
821             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
822                      reason);
823             return 0;
824         }
825     }
826
827     /* Add custom extensions first */
828     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
829         /* On the server side with initialise during ClientHello parsing */
830         custom_ext_init(&s->cert->custext);
831     }
832     if (!custom_ext_add(s, context, pkt, x, chainidx, max_version)) {
833         /* SSLfatal() already called */
834         return 0;
835     }
836
837     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
838         EXT_RETURN (*construct)(SSL *s, WPACKET *pkt, unsigned int context,
839                                 X509 *x, size_t chainidx);
840         EXT_RETURN ret;
841
842         /* Skip if not relevant for our context */
843         if (!should_add_extension(s, thisexd->context, context, max_version))
844             continue;
845
846         construct = s->server ? thisexd->construct_stoc
847                               : thisexd->construct_ctos;
848
849         if (construct == NULL)
850             continue;
851
852         ret = construct(s, pkt, context, x, chainidx);
853         if (ret == EXT_RETURN_FAIL) {
854             /* SSLfatal() already called */
855             return 0;
856         }
857         if (ret == EXT_RETURN_SENT
858                 && (context & (SSL_EXT_CLIENT_HELLO
859                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
860                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0)
861             s->ext.extflags[i] |= SSL_EXT_FLAG_SENT;
862     }
863
864     if (!WPACKET_close(pkt)) {
865         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
866                  ERR_R_INTERNAL_ERROR);
867         return 0;
868     }
869
870     return 1;
871 }
872
873 /*
874  * Built in extension finalisation and initialisation functions. All initialise
875  * or finalise the associated extension type for the given |context|. For
876  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
877  * otherwise. These functions return 1 on success or 0 on failure.
878  */
879
880 static int final_renegotiate(SSL *s, unsigned int context, int sent)
881 {
882     if (!s->server) {
883         /*
884          * Check if we can connect to a server that doesn't support safe
885          * renegotiation
886          */
887         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
888                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
889                 && !sent) {
890             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_RENEGOTIATE,
891                      SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
892             return 0;
893         }
894
895         return 1;
896     }
897
898     /* Need RI if renegotiating */
899     if (s->renegotiate
900             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
901             && !sent) {
902         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_RENEGOTIATE,
903                  SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
904         return 0;
905     }
906
907
908     return 1;
909 }
910
911 static int init_server_name(SSL *s, unsigned int context)
912 {
913     if (s->server) {
914         s->servername_done = 0;
915
916         OPENSSL_free(s->ext.hostname);
917         s->ext.hostname = NULL;
918     }
919
920     return 1;
921 }
922
923 static int final_server_name(SSL *s, unsigned int context, int sent)
924 {
925     int ret = SSL_TLSEXT_ERR_NOACK;
926     int altmp = SSL_AD_UNRECOGNIZED_NAME;
927     int was_ticket = (SSL_get_options(s) & SSL_OP_NO_TICKET) == 0;
928
929     if (!ossl_assert(s->ctx != NULL) || !ossl_assert(s->session_ctx != NULL)) {
930         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
931                  ERR_R_INTERNAL_ERROR);
932         return 0;
933     }
934
935     if (s->ctx->ext.servername_cb != NULL)
936         ret = s->ctx->ext.servername_cb(s, &altmp,
937                                         s->ctx->ext.servername_arg);
938     else if (s->session_ctx->ext.servername_cb != NULL)
939         ret = s->session_ctx->ext.servername_cb(s, &altmp,
940                                        s->session_ctx->ext.servername_arg);
941
942     /*
943      * For servers, propagate the SNI hostname from the temporary
944      * storage in the SSL to the persistent SSL_SESSION, now that we
945      * know we accepted it.
946      * Clients make this copy when parsing the server's response to
947      * the extension, which is when they find out that the negotiation
948      * was successful.
949      */
950     if (s->server) {
951         /* TODO(OpenSSL1.2) revisit !sent case */
952         if (sent && ret == SSL_TLSEXT_ERR_OK && !s->hit) {
953             /* Only store the hostname in the session if we accepted it. */
954             OPENSSL_free(s->session->ext.hostname);
955             s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname);
956             if (s->session->ext.hostname == NULL && s->ext.hostname != NULL) {
957                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
958                          ERR_R_INTERNAL_ERROR);
959             }
960         }
961     }
962
963     /*
964      * If we switched contexts (whether here or in the client_hello callback),
965      * move the sess_accept increment from the session_ctx to the new
966      * context, to avoid the confusing situation of having sess_accept_good
967      * exceed sess_accept (zero) for the new context.
968      */
969     if (SSL_IS_FIRST_HANDSHAKE(s) && s->ctx != s->session_ctx) {
970         tsan_counter(&s->ctx->stats.sess_accept);
971         tsan_decr(&s->session_ctx->stats.sess_accept);
972     }
973
974     /*
975      * If we're expecting to send a ticket, and tickets were previously enabled,
976      * and now tickets are disabled, then turn off expected ticket.
977      * Also, if this is not a resumption, create a new session ID
978      */
979     if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected
980             && was_ticket && (SSL_get_options(s) & SSL_OP_NO_TICKET) != 0) {
981         s->ext.ticket_expected = 0;
982         if (!s->hit) {
983             SSL_SESSION* ss = SSL_get_session(s);
984
985             if (ss != NULL) {
986                 OPENSSL_free(ss->ext.tick);
987                 ss->ext.tick = NULL;
988                 ss->ext.ticklen = 0;
989                 ss->ext.tick_lifetime_hint = 0;
990                 ss->ext.tick_age_add = 0;
991                 if (!ssl_generate_session_id(s, ss)) {
992                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
993                              ERR_R_INTERNAL_ERROR);
994                     return 0;
995                 }
996             } else {
997                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
998                          ERR_R_INTERNAL_ERROR);
999                 return 0;
1000             }
1001         }
1002     }
1003
1004     switch (ret) {
1005     case SSL_TLSEXT_ERR_ALERT_FATAL:
1006         SSLfatal(s, altmp, SSL_F_FINAL_SERVER_NAME, SSL_R_CALLBACK_FAILED);
1007         return 0;
1008
1009     case SSL_TLSEXT_ERR_ALERT_WARNING:
1010         /* TLSv1.3 doesn't have warning alerts so we suppress this */
1011         if (!SSL_IS_TLS13(s))
1012             ssl3_send_alert(s, SSL3_AL_WARNING, altmp);
1013         return 1;
1014
1015     case SSL_TLSEXT_ERR_NOACK:
1016         s->servername_done = 0;
1017         return 1;
1018
1019     default:
1020         return 1;
1021     }
1022 }
1023
1024 #ifndef OPENSSL_NO_EC
1025 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent)
1026 {
1027     unsigned long alg_k, alg_a;
1028
1029     if (s->server)
1030         return 1;
1031
1032     alg_k = s->s3.tmp.new_cipher->algorithm_mkey;
1033     alg_a = s->s3.tmp.new_cipher->algorithm_auth;
1034
1035     /*
1036      * If we are client and using an elliptic curve cryptography cipher
1037      * suite, then if server returns an EC point formats lists extension it
1038      * must contain uncompressed.
1039      */
1040     if (s->ext.ecpointformats != NULL
1041             && s->ext.ecpointformats_len > 0
1042             && s->ext.peer_ecpointformats != NULL
1043             && s->ext.peer_ecpointformats_len > 0
1044             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
1045         /* we are using an ECC cipher */
1046         size_t i;
1047         unsigned char *list = s->ext.peer_ecpointformats;
1048
1049         for (i = 0; i < s->ext.peer_ecpointformats_len; i++) {
1050             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
1051                 break;
1052         }
1053         if (i == s->ext.peer_ecpointformats_len) {
1054             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EC_PT_FORMATS,
1055                      SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1056             return 0;
1057         }
1058     }
1059
1060     return 1;
1061 }
1062 #endif
1063
1064 static int init_session_ticket(SSL *s, unsigned int context)
1065 {
1066     if (!s->server)
1067         s->ext.ticket_expected = 0;
1068
1069     return 1;
1070 }
1071
1072 #ifndef OPENSSL_NO_OCSP
1073 static int init_status_request(SSL *s, unsigned int context)
1074 {
1075     if (s->server) {
1076         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
1077     } else {
1078         /*
1079          * Ensure we get sensible values passed to tlsext_status_cb in the event
1080          * that we don't receive a status message
1081          */
1082         OPENSSL_free(s->ext.ocsp.resp);
1083         s->ext.ocsp.resp = NULL;
1084         s->ext.ocsp.resp_len = 0;
1085     }
1086
1087     return 1;
1088 }
1089 #endif
1090
1091 #ifndef OPENSSL_NO_NEXTPROTONEG
1092 static int init_npn(SSL *s, unsigned int context)
1093 {
1094     s->s3.npn_seen = 0;
1095
1096     return 1;
1097 }
1098 #endif
1099
1100 static int init_alpn(SSL *s, unsigned int context)
1101 {
1102     OPENSSL_free(s->s3.alpn_selected);
1103     s->s3.alpn_selected = NULL;
1104     s->s3.alpn_selected_len = 0;
1105     if (s->server) {
1106         OPENSSL_free(s->s3.alpn_proposed);
1107         s->s3.alpn_proposed = NULL;
1108         s->s3.alpn_proposed_len = 0;
1109     }
1110     return 1;
1111 }
1112
1113 static int final_alpn(SSL *s, unsigned int context, int sent)
1114 {
1115     if (!s->server && !sent && s->session->ext.alpn_selected != NULL)
1116             s->ext.early_data_ok = 0;
1117
1118     if (!s->server || !SSL_IS_TLS13(s))
1119         return 1;
1120
1121     /*
1122      * Call alpn_select callback if needed.  Has to be done after SNI and
1123      * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3
1124      * we also have to do this before we decide whether to accept early_data.
1125      * In TLSv1.3 we've already negotiated our cipher so we do this call now.
1126      * For < TLSv1.3 we defer it until after cipher negotiation.
1127      *
1128      * On failure SSLfatal() already called.
1129      */
1130     return tls_handle_alpn(s);
1131 }
1132
1133 static int init_sig_algs(SSL *s, unsigned int context)
1134 {
1135     /* Clear any signature algorithms extension received */
1136     OPENSSL_free(s->s3.tmp.peer_sigalgs);
1137     s->s3.tmp.peer_sigalgs = NULL;
1138
1139     return 1;
1140 }
1141
1142 static int init_sig_algs_cert(SSL *s, unsigned int context)
1143 {
1144     /* Clear any signature algorithms extension received */
1145     OPENSSL_free(s->s3.tmp.peer_cert_sigalgs);
1146     s->s3.tmp.peer_cert_sigalgs = NULL;
1147
1148     return 1;
1149 }
1150
1151 #ifndef OPENSSL_NO_SRP
1152 static int init_srp(SSL *s, unsigned int context)
1153 {
1154     OPENSSL_free(s->srp_ctx.login);
1155     s->srp_ctx.login = NULL;
1156
1157     return 1;
1158 }
1159 #endif
1160
1161 static int init_etm(SSL *s, unsigned int context)
1162 {
1163     s->ext.use_etm = 0;
1164
1165     return 1;
1166 }
1167
1168 static int init_ems(SSL *s, unsigned int context)
1169 {
1170     s->s3.flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1171
1172     return 1;
1173 }
1174
1175 static int final_ems(SSL *s, unsigned int context, int sent)
1176 {
1177     if (!s->server && s->hit) {
1178         /*
1179          * Check extended master secret extension is consistent with
1180          * original session.
1181          */
1182         if (!(s->s3.flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1183             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1184             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_EMS,
1185                      SSL_R_INCONSISTENT_EXTMS);
1186             return 0;
1187         }
1188     }
1189
1190     return 1;
1191 }
1192
1193 static int init_certificate_authorities(SSL *s, unsigned int context)
1194 {
1195     sk_X509_NAME_pop_free(s->s3.tmp.peer_ca_names, X509_NAME_free);
1196     s->s3.tmp.peer_ca_names = NULL;
1197     return 1;
1198 }
1199
1200 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
1201                                                         unsigned int context,
1202                                                         X509 *x,
1203                                                         size_t chainidx)
1204 {
1205     const STACK_OF(X509_NAME) *ca_sk = get_ca_names(s);
1206
1207     if (ca_sk == NULL || sk_X509_NAME_num(ca_sk) == 0)
1208         return EXT_RETURN_NOT_SENT;
1209
1210     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities)
1211         || !WPACKET_start_sub_packet_u16(pkt)) {
1212         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1213                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1214                ERR_R_INTERNAL_ERROR);
1215         return EXT_RETURN_FAIL;
1216     }
1217
1218     if (!construct_ca_names(s, ca_sk, pkt)) {
1219         /* SSLfatal() already called */
1220         return EXT_RETURN_FAIL;
1221     }
1222
1223     if (!WPACKET_close(pkt)) {
1224         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1225                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1226                  ERR_R_INTERNAL_ERROR);
1227         return EXT_RETURN_FAIL;
1228     }
1229
1230     return EXT_RETURN_SENT;
1231 }
1232
1233 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
1234                                              unsigned int context, X509 *x,
1235                                              size_t chainidx)
1236 {
1237     if (!parse_ca_names(s, pkt))
1238         return 0;
1239     if (PACKET_remaining(pkt) != 0) {
1240         SSLfatal(s, SSL_AD_DECODE_ERROR,
1241                  SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES, SSL_R_BAD_EXTENSION);
1242         return 0;
1243     }
1244     return 1;
1245 }
1246
1247 #ifndef OPENSSL_NO_SRTP
1248 static int init_srtp(SSL *s, unsigned int context)
1249 {
1250     if (s->server)
1251         s->srtp_profile = NULL;
1252
1253     return 1;
1254 }
1255 #endif
1256
1257 static int final_sig_algs(SSL *s, unsigned int context, int sent)
1258 {
1259     if (!sent && SSL_IS_TLS13(s) && !s->hit) {
1260         SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_F_FINAL_SIG_ALGS,
1261                  SSL_R_MISSING_SIGALGS_EXTENSION);
1262         return 0;
1263     }
1264
1265     return 1;
1266 }
1267
1268 static int final_key_share(SSL *s, unsigned int context, int sent)
1269 {
1270 #if !defined(OPENSSL_NO_TLS1_3)
1271     if (!SSL_IS_TLS13(s))
1272         return 1;
1273
1274     /* Nothing to do for key_share in an HRR */
1275     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
1276         return 1;
1277
1278     /*
1279      * If
1280      *     we are a client
1281      *     AND
1282      *     we have no key_share
1283      *     AND
1284      *     (we are not resuming
1285      *      OR the kex_mode doesn't allow non key_share resumes)
1286      * THEN
1287      *     fail;
1288      */
1289     if (!s->server
1290             && !sent
1291             && (!s->hit
1292                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) {
1293         /* Nothing left we can do - just fail */
1294         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_KEY_SHARE,
1295                  SSL_R_NO_SUITABLE_KEY_SHARE);
1296         return 0;
1297     }
1298     /*
1299      * IF
1300      *     we are a server
1301      * THEN
1302      *     IF
1303      *         we have a suitable key_share
1304      *     THEN
1305      *         IF
1306      *             we are stateless AND we have no cookie
1307      *         THEN
1308      *             send a HelloRetryRequest
1309      *     ELSE
1310      *         IF
1311      *             we didn't already send a HelloRetryRequest
1312      *             AND
1313      *             the client sent a key_share extension
1314      *             AND
1315      *             (we are not resuming
1316      *              OR the kex_mode allows key_share resumes)
1317      *             AND
1318      *             a shared group exists
1319      *         THEN
1320      *             send a HelloRetryRequest
1321      *         ELSE IF
1322      *             we are not resuming
1323      *             OR
1324      *             the kex_mode doesn't allow non key_share resumes
1325      *         THEN
1326      *             fail
1327      *         ELSE IF
1328      *             we are stateless AND we have no cookie
1329      *         THEN
1330      *             send a HelloRetryRequest
1331      */
1332     if (s->server) {
1333         if (s->s3.peer_tmp != NULL) {
1334             /* We have a suitable key_share */
1335             if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0
1336                     && !s->ext.cookieok) {
1337                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1338                     /*
1339                      * If we are stateless then we wouldn't know about any
1340                      * previously sent HRR - so how can this be anything other
1341                      * than 0?
1342                      */
1343                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1344                              ERR_R_INTERNAL_ERROR);
1345                     return 0;
1346                 }
1347                 s->hello_retry_request = SSL_HRR_PENDING;
1348                 return 1;
1349             }
1350         } else {
1351             /* No suitable key_share */
1352             if (s->hello_retry_request == SSL_HRR_NONE && sent
1353                     && (!s->hit
1354                         || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE)
1355                            != 0)) {
1356                 const uint16_t *pgroups, *clntgroups;
1357                 size_t num_groups, clnt_num_groups, i;
1358                 unsigned int group_id = 0;
1359
1360                 /* Check if a shared group exists */
1361
1362                 /* Get the clients list of supported groups. */
1363                 tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups);
1364                 tls1_get_supported_groups(s, &pgroups, &num_groups);
1365
1366                 /*
1367                  * Find the first group we allow that is also in client's list
1368                  */
1369                 for (i = 0; i < num_groups; i++) {
1370                     group_id = pgroups[i];
1371
1372                     if (check_in_list(s, group_id, clntgroups, clnt_num_groups,
1373                                       1))
1374                         break;
1375                 }
1376
1377                 if (i < num_groups) {
1378                     /* A shared group exists so send a HelloRetryRequest */
1379                     s->s3.group_id = group_id;
1380                     s->hello_retry_request = SSL_HRR_PENDING;
1381                     return 1;
1382                 }
1383             }
1384             if (!s->hit
1385                     || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
1386                 /* Nothing left we can do - just fail */
1387                 SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE
1388                                  : SSL_AD_MISSING_EXTENSION,
1389                          SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
1390                 return 0;
1391             }
1392
1393             if ((s->s3.flags & TLS1_FLAGS_STATELESS) != 0
1394                     && !s->ext.cookieok) {
1395                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1396                     /*
1397                      * If we are stateless then we wouldn't know about any
1398                      * previously sent HRR - so how can this be anything other
1399                      * than 0?
1400                      */
1401                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1402                              ERR_R_INTERNAL_ERROR);
1403                     return 0;
1404                 }
1405                 s->hello_retry_request = SSL_HRR_PENDING;
1406                 return 1;
1407             }
1408         }
1409
1410         /*
1411          * We have a key_share so don't send any more HelloRetryRequest
1412          * messages
1413          */
1414         if (s->hello_retry_request == SSL_HRR_PENDING)
1415             s->hello_retry_request = SSL_HRR_COMPLETE;
1416     } else {
1417         /*
1418          * For a client side resumption with no key_share we need to generate
1419          * the handshake secret (otherwise this is done during key_share
1420          * processing).
1421          */
1422         if (!sent && !tls13_generate_handshake_secret(s, NULL, 0)) {
1423             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1424                      ERR_R_INTERNAL_ERROR);
1425             return 0;
1426         }
1427     }
1428 #endif /* !defined(OPENSSL_NO_TLS1_3) */
1429     return 1;
1430 }
1431
1432 static int init_psk_kex_modes(SSL *s, unsigned int context)
1433 {
1434     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
1435     return 1;
1436 }
1437
1438 int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
1439                       size_t binderoffset, const unsigned char *binderin,
1440                       unsigned char *binderout, SSL_SESSION *sess, int sign,
1441                       int external)
1442 {
1443     EVP_PKEY *mackey = NULL;
1444     EVP_MD_CTX *mctx = NULL;
1445     unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE];
1446     unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE];
1447     unsigned char *early_secret;
1448 #ifdef CHARSET_EBCDIC
1449     static const unsigned char resumption_label[] = { 0x72, 0x65, 0x73, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x65, 0x72, 0x00 };
1450     static const unsigned char external_label[]   = { 0x65, 0x78, 0x74, 0x20, 0x62, 0x69, 0x6E, 0x64, 0x65, 0x72, 0x00 };
1451 #else
1452     static const unsigned char resumption_label[] = "res binder";
1453     static const unsigned char external_label[] = "ext binder";
1454 #endif
1455     const unsigned char *label;
1456     size_t bindersize, labelsize, hashsize;
1457     int hashsizei = EVP_MD_size(md);
1458     int ret = -1;
1459     int usepskfored = 0;
1460
1461     /* Ensure cast to size_t is safe */
1462     if (!ossl_assert(hashsizei >= 0)) {
1463         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1464                  ERR_R_INTERNAL_ERROR);
1465         goto err;
1466     }
1467     hashsize = (size_t)hashsizei;
1468
1469     if (external
1470             && s->early_data_state == SSL_EARLY_DATA_CONNECTING
1471             && s->session->ext.max_early_data == 0
1472             && sess->ext.max_early_data > 0)
1473         usepskfored = 1;
1474
1475     if (external) {
1476         label = external_label;
1477         labelsize = sizeof(external_label) - 1;
1478     } else {
1479         label = resumption_label;
1480         labelsize = sizeof(resumption_label) - 1;
1481     }
1482
1483     /*
1484      * Generate the early_secret. On the server side we've selected a PSK to
1485      * resume with (internal or external) so we always do this. On the client
1486      * side we do this for a non-external (i.e. resumption) PSK or external PSK
1487      * that will be used for early_data so that it is in place for sending early
1488      * data. For client side external PSK not being used for early_data we
1489      * generate it but store it away for later use.
1490      */
1491     if (s->server || !external || usepskfored)
1492         early_secret = (unsigned char *)s->early_secret;
1493     else
1494         early_secret = (unsigned char *)sess->early_secret;
1495
1496     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
1497                                sess->master_key_length, early_secret)) {
1498         /* SSLfatal() already called */
1499         goto err;
1500     }
1501
1502     /*
1503      * Create the handshake hash for the binder key...the messages so far are
1504      * empty!
1505      */
1506     mctx = EVP_MD_CTX_new();
1507     if (mctx == NULL
1508             || EVP_DigestInit_ex(mctx, md, NULL) <= 0
1509             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1510         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1511                  ERR_R_INTERNAL_ERROR);
1512         goto err;
1513     }
1514
1515     /* Generate the binder key */
1516     if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash,
1517                            hashsize, binderkey, hashsize, 1)) {
1518         /* SSLfatal() already called */
1519         goto err;
1520     }
1521
1522     /* Generate the finished key */
1523     if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) {
1524         /* SSLfatal() already called */
1525         goto err;
1526     }
1527
1528     if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) {
1529         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1530                  ERR_R_INTERNAL_ERROR);
1531         goto err;
1532     }
1533
1534     /*
1535      * Get a hash of the ClientHello up to the start of the binders. If we are
1536      * following a HelloRetryRequest then this includes the hash of the first
1537      * ClientHello and the HelloRetryRequest itself.
1538      */
1539     if (s->hello_retry_request == SSL_HRR_PENDING) {
1540         size_t hdatalen;
1541         long hdatalen_l;
1542         void *hdata;
1543
1544         hdatalen = hdatalen_l =
1545             BIO_get_mem_data(s->s3.handshake_buffer, &hdata);
1546         if (hdatalen_l <= 0) {
1547             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1548                      SSL_R_BAD_HANDSHAKE_LENGTH);
1549             goto err;
1550         }
1551
1552         /*
1553          * For servers the handshake buffer data will include the second
1554          * ClientHello - which we don't want - so we need to take that bit off.
1555          */
1556         if (s->server) {
1557             PACKET hashprefix, msg;
1558
1559             /* Find how many bytes are left after the first two messages */
1560             if (!PACKET_buf_init(&hashprefix, hdata, hdatalen)
1561                     || !PACKET_forward(&hashprefix, 1)
1562                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
1563                     || !PACKET_forward(&hashprefix, 1)
1564                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
1565                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1566                          ERR_R_INTERNAL_ERROR);
1567                 goto err;
1568             }
1569             hdatalen -= PACKET_remaining(&hashprefix);
1570         }
1571
1572         if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) {
1573             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1574                      ERR_R_INTERNAL_ERROR);
1575             goto err;
1576         }
1577     }
1578
1579     if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
1580             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1581         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1582                  ERR_R_INTERNAL_ERROR);
1583         goto err;
1584     }
1585
1586     mackey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, finishedkey,
1587                                           hashsize);
1588     if (mackey == NULL) {
1589         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1590                  ERR_R_INTERNAL_ERROR);
1591         goto err;
1592     }
1593
1594     if (!sign)
1595         binderout = tmpbinder;
1596
1597     bindersize = hashsize;
1598     if (EVP_DigestSignInit(mctx, NULL, md, NULL, mackey) <= 0
1599             || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
1600             || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
1601             || bindersize != hashsize) {
1602         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1603                  ERR_R_INTERNAL_ERROR);
1604         goto err;
1605     }
1606
1607     if (sign) {
1608         ret = 1;
1609     } else {
1610         /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */
1611         ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0);
1612         if (!ret)
1613             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PSK_DO_BINDER,
1614                      SSL_R_BINDER_DOES_NOT_VERIFY);
1615     }
1616
1617  err:
1618     OPENSSL_cleanse(binderkey, sizeof(binderkey));
1619     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
1620     EVP_PKEY_free(mackey);
1621     EVP_MD_CTX_free(mctx);
1622
1623     return ret;
1624 }
1625
1626 static int final_early_data(SSL *s, unsigned int context, int sent)
1627 {
1628     if (!sent)
1629         return 1;
1630
1631     if (!s->server) {
1632         if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1633                 && sent
1634                 && !s->ext.early_data_ok) {
1635             /*
1636              * If we get here then the server accepted our early_data but we
1637              * later realised that it shouldn't have done (e.g. inconsistent
1638              * ALPN)
1639              */
1640             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EARLY_DATA,
1641                      SSL_R_BAD_EARLY_DATA);
1642             return 0;
1643         }
1644
1645         return 1;
1646     }
1647
1648     if (s->max_early_data == 0
1649             || !s->hit
1650             || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
1651             || !s->ext.early_data_ok
1652             || s->hello_retry_request != SSL_HRR_NONE
1653             || (s->allow_early_data_cb != NULL
1654                 && !s->allow_early_data_cb(s,
1655                                          s->allow_early_data_cb_data))) {
1656         s->ext.early_data = SSL_EARLY_DATA_REJECTED;
1657     } else {
1658         s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1659
1660         if (!tls13_change_cipher_state(s,
1661                     SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
1662             /* SSLfatal() already called */
1663             return 0;
1664         }
1665     }
1666
1667     return 1;
1668 }
1669
1670 static int final_maxfragmentlen(SSL *s, unsigned int context, int sent)
1671 {
1672     /*
1673      * Session resumption on server-side with MFL extension active
1674      *  BUT MFL extension packet was not resent (i.e. sent == 0)
1675      */
1676     if (s->server && s->hit && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1677             && !sent ) {
1678         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_MAXFRAGMENTLEN,
1679                  SSL_R_BAD_EXTENSION);
1680         return 0;
1681     }
1682
1683     /* Current SSL buffer is lower than requested MFL */
1684     if (s->session && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1685             && s->max_send_fragment < GET_MAX_FRAGMENT_LENGTH(s->session))
1686         /* trigger a larger buffer reallocation */
1687         if (!ssl3_setup_buffers(s)) {
1688             /* SSLfatal() already called */
1689             return 0;
1690         }
1691
1692     return 1;
1693 }
1694
1695 static int init_post_handshake_auth(SSL *s, unsigned int context)
1696 {
1697     s->post_handshake_auth = SSL_PHA_NONE;
1698
1699     return 1;
1700 }