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