Don't write the tick_identity to the session
[openssl.git] / ssl / statem / extensions.c
1 /*
2  * Copyright 2016-2019 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. We allow it in a ClientHello but
352          * ignore it.
353          */
354         TLSEXT_TYPE_cryptopro_bug,
355         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
356         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
357         NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
358     },
359     {
360         TLSEXT_TYPE_early_data,
361         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
362         | SSL_EXT_TLS1_3_NEW_SESSION_TICKET | SSL_EXT_TLS1_3_ONLY,
363         NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data,
364         tls_construct_stoc_early_data, tls_construct_ctos_early_data,
365         final_early_data
366     },
367     {
368         TLSEXT_TYPE_certificate_authorities,
369         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
370         | SSL_EXT_TLS1_3_ONLY,
371         init_certificate_authorities,
372         tls_parse_certificate_authorities, tls_parse_certificate_authorities,
373         tls_construct_certificate_authorities,
374         tls_construct_certificate_authorities, NULL,
375     },
376     {
377         /* Must be immediately before pre_shared_key */
378         TLSEXT_TYPE_padding,
379         SSL_EXT_CLIENT_HELLO,
380         NULL,
381         /* We send this, but don't read it */
382         NULL, NULL, NULL, tls_construct_ctos_padding, NULL
383     },
384     {
385         /* Required by the TLSv1.3 spec to always be the last extension */
386         TLSEXT_TYPE_psk,
387         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
388         | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
389         NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk,
390         tls_construct_ctos_psk, NULL
391     }
392 };
393
394 /* Check whether an extension's context matches the current context */
395 static int validate_context(SSL *s, unsigned int extctx, unsigned int thisctx)
396 {
397     /* Check we're allowed to use this extension in this context */
398     if ((thisctx & extctx) == 0)
399         return 0;
400
401     if (SSL_IS_DTLS(s)) {
402         if ((extctx & SSL_EXT_TLS_ONLY) != 0)
403             return 0;
404     } else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) {
405         return 0;
406     }
407
408     return 1;
409 }
410
411 int tls_validate_all_contexts(SSL *s, unsigned int thisctx, RAW_EXTENSION *exts)
412 {
413     size_t i, num_exts, builtin_num = OSSL_NELEM(ext_defs), offset;
414     RAW_EXTENSION *thisext;
415     unsigned int context;
416     ENDPOINT role = ENDPOINT_BOTH;
417
418     if ((thisctx & SSL_EXT_CLIENT_HELLO) != 0)
419         role = ENDPOINT_SERVER;
420     else if ((thisctx & SSL_EXT_TLS1_2_SERVER_HELLO) != 0)
421         role = ENDPOINT_CLIENT;
422
423     /* Calculate the number of extensions in the extensions list */
424     num_exts = builtin_num + s->cert->custext.meths_count;
425
426     for (thisext = exts, i = 0; i < num_exts; i++, thisext++) {
427         if (!thisext->present)
428             continue;
429
430         if (i < builtin_num) {
431             context = ext_defs[i].context;
432         } else {
433             custom_ext_method *meth = NULL;
434
435             meth = custom_ext_find(&s->cert->custext, role, thisext->type,
436                                    &offset);
437             if (!ossl_assert(meth != NULL))
438                 return 0;
439             context = meth->context;
440         }
441
442         if (!validate_context(s, context, thisctx))
443             return 0;
444     }
445
446     return 1;
447 }
448
449 /*
450  * Verify whether we are allowed to use the extension |type| in the current
451  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
452  * indicate the extension is not allowed. If returning 1 then |*found| is set to
453  * the definition for the extension we found.
454  */
455 static int verify_extension(SSL *s, unsigned int context, unsigned int type,
456                             custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
457                             RAW_EXTENSION **found)
458 {
459     size_t i;
460     size_t builtin_num = OSSL_NELEM(ext_defs);
461     const EXTENSION_DEFINITION *thisext;
462
463     for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) {
464         if (type == thisext->type) {
465             if (!validate_context(s, thisext->context, context))
466                 return 0;
467
468             *found = &rawexlist[i];
469             return 1;
470         }
471     }
472
473     /* Check the custom extensions */
474     if (meths != NULL) {
475         size_t offset = 0;
476         ENDPOINT role = ENDPOINT_BOTH;
477         custom_ext_method *meth = NULL;
478
479         if ((context & SSL_EXT_CLIENT_HELLO) != 0)
480             role = ENDPOINT_SERVER;
481         else if ((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0)
482             role = ENDPOINT_CLIENT;
483
484         meth = custom_ext_find(meths, role, type, &offset);
485         if (meth != NULL) {
486             if (!validate_context(s, meth->context, context))
487                 return 0;
488             *found = &rawexlist[offset + builtin_num];
489             return 1;
490         }
491     }
492
493     /* Unknown extension. We allow it */
494     *found = NULL;
495     return 1;
496 }
497
498 /*
499  * Check whether the context defined for an extension |extctx| means whether
500  * the extension is relevant for the current context |thisctx| or not. Returns
501  * 1 if the extension is relevant for this context, and 0 otherwise
502  */
503 int extension_is_relevant(SSL *s, unsigned int extctx, unsigned int thisctx)
504 {
505     int is_tls13;
506
507     /*
508      * For HRR we haven't selected the version yet but we know it will be
509      * TLSv1.3
510      */
511     if ((thisctx & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
512         is_tls13 = 1;
513     else
514         is_tls13 = SSL_IS_TLS13(s);
515
516     if ((SSL_IS_DTLS(s)
517                 && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
518             || (s->version == SSL3_VERSION
519                     && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
520             /*
521              * Note that SSL_IS_TLS13() means "TLS 1.3 has been negotiated",
522              * which is never true when generating the ClientHello.
523              * However, version negotiation *has* occurred by the time the
524              * ClientHello extensions are being parsed.
525              * Be careful to allow TLS 1.3-only extensions when generating
526              * the ClientHello.
527              */
528             || (is_tls13 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
529             || (!is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0
530                 && (thisctx & SSL_EXT_CLIENT_HELLO) == 0)
531             || (s->server && !is_tls13 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0)
532             || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0))
533         return 0;
534     return 1;
535 }
536
537 /*
538  * Gather a list of all the extensions from the data in |packet]. |context|
539  * tells us which message this extension is for. The raw extension data is
540  * stored in |*res| on success. We don't actually process the content of the
541  * extensions yet, except to check their types. This function also runs the
542  * initialiser functions for all known extensions if |init| is nonzero (whether
543  * we have collected them or not). If successful the caller is responsible for
544  * freeing the contents of |*res|.
545  *
546  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
547  * more than one extension of the same type in a ClientHello or ServerHello.
548  * This function returns 1 if all extensions are unique and we have parsed their
549  * types, and 0 if the extensions contain duplicates, could not be successfully
550  * found, or an internal error occurred. We only check duplicates for
551  * extensions that we know about. We ignore others.
552  */
553 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
554                            RAW_EXTENSION **res, size_t *len, int init)
555 {
556     PACKET extensions = *packet;
557     size_t i = 0;
558     size_t num_exts;
559     custom_ext_methods *exts = &s->cert->custext;
560     RAW_EXTENSION *raw_extensions = NULL;
561     const EXTENSION_DEFINITION *thisexd;
562
563     *res = NULL;
564
565     /*
566      * Initialise server side custom extensions. Client side is done during
567      * construction of extensions for the ClientHello.
568      */
569     if ((context & SSL_EXT_CLIENT_HELLO) != 0)
570         custom_ext_init(&s->cert->custext);
571
572     num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0);
573     raw_extensions = OPENSSL_zalloc(num_exts * sizeof(*raw_extensions));
574     if (raw_extensions == NULL) {
575         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_COLLECT_EXTENSIONS,
576                  ERR_R_MALLOC_FAILURE);
577         return 0;
578     }
579
580     i = 0;
581     while (PACKET_remaining(&extensions) > 0) {
582         unsigned int type, idx;
583         PACKET extension;
584         RAW_EXTENSION *thisex;
585
586         if (!PACKET_get_net_2(&extensions, &type) ||
587             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
588             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_COLLECT_EXTENSIONS,
589                      SSL_R_BAD_EXTENSION);
590             goto err;
591         }
592         /*
593          * Verify this extension is allowed. We only check duplicates for
594          * extensions that we recognise. We also have a special case for the
595          * PSK extension, which must be the last one in the ClientHello.
596          */
597         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
598                 || (thisex != NULL && thisex->present == 1)
599                 || (type == TLSEXT_TYPE_psk
600                     && (context & SSL_EXT_CLIENT_HELLO) != 0
601                     && PACKET_remaining(&extensions) != 0)) {
602             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_COLLECT_EXTENSIONS,
603                      SSL_R_BAD_EXTENSION);
604             goto err;
605         }
606         idx = thisex - raw_extensions;
607         /*-
608          * Check that we requested this extension (if appropriate). Requests can
609          * be sent in the ClientHello and CertificateRequest. Unsolicited
610          * extensions can be sent in the NewSessionTicket. We only do this for
611          * the built-in extensions. Custom extensions have a different but
612          * similar check elsewhere.
613          * Special cases:
614          * - The HRR cookie extension is unsolicited
615          * - The renegotiate extension is unsolicited (the client signals
616          *   support via an SCSV)
617          * - The signed_certificate_timestamp extension can be provided by a
618          * custom extension or by the built-in version. We let the extension
619          * itself handle unsolicited response checks.
620          */
621         if (idx < OSSL_NELEM(ext_defs)
622                 && (context & (SSL_EXT_CLIENT_HELLO
623                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
624                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0
625                 && type != TLSEXT_TYPE_cookie
626                 && type != TLSEXT_TYPE_renegotiate
627                 && type != TLSEXT_TYPE_signed_certificate_timestamp
628                 && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0
629 #ifndef OPENSSL_NO_GOST
630                 && !((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
631                      && type == TLSEXT_TYPE_cryptopro_bug)
632 #endif
633                                                                 ) {
634             SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION,
635                      SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_UNSOLICITED_EXTENSION);
636             goto err;
637         }
638         if (thisex != NULL) {
639             thisex->data = extension;
640             thisex->present = 1;
641             thisex->type = type;
642             thisex->received_order = i++;
643             if (s->ext.debug_cb)
644                 s->ext.debug_cb(s, !s->server, thisex->type,
645                                 PACKET_data(&thisex->data),
646                                 PACKET_remaining(&thisex->data),
647                                 s->ext.debug_arg);
648         }
649     }
650
651     if (init) {
652         /*
653          * Initialise all known extensions relevant to this context,
654          * whether we have found them or not
655          */
656         for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs);
657              i++, thisexd++) {
658             if (thisexd->init != NULL && (thisexd->context & context) != 0
659                 && extension_is_relevant(s, thisexd->context, context)
660                 && !thisexd->init(s, context)) {
661                 /* SSLfatal() already called */
662                 goto err;
663             }
664         }
665     }
666
667     *res = raw_extensions;
668     if (len != NULL)
669         *len = num_exts;
670     return 1;
671
672  err:
673     OPENSSL_free(raw_extensions);
674     return 0;
675 }
676
677 /*
678  * Runs the parser for a given extension with index |idx|. |exts| contains the
679  * list of all parsed extensions previously collected by
680  * tls_collect_extensions(). The parser is only run if it is applicable for the
681  * given |context| and the parser has not already been run. If this is for a
682  * Certificate message, then we also provide the parser with the relevant
683  * Certificate |x| and its position in the |chainidx| with 0 being the first
684  * Certificate. Returns 1 on success or 0 on failure. If an extension is not
685  * present this counted as success.
686  */
687 int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
688                         RAW_EXTENSION *exts, X509 *x, size_t chainidx)
689 {
690     RAW_EXTENSION *currext = &exts[idx];
691     int (*parser)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
692                   size_t chainidx) = NULL;
693
694     /* Skip if the extension is not present */
695     if (!currext->present)
696         return 1;
697
698     /* Skip if we've already parsed this extension */
699     if (currext->parsed)
700         return 1;
701
702     currext->parsed = 1;
703
704     if (idx < OSSL_NELEM(ext_defs)) {
705         /* We are handling a built-in extension */
706         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
707
708         /* Check if extension is defined for our protocol. If not, skip */
709         if (!extension_is_relevant(s, extdef->context, context))
710             return 1;
711
712         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
713
714         if (parser != NULL)
715             return parser(s, &currext->data, context, x, chainidx);
716
717         /*
718          * If the parser is NULL we fall through to the custom extension
719          * processing
720          */
721     }
722
723     /* Parse custom extensions */
724     return custom_ext_parse(s, context, currext->type,
725                             PACKET_data(&currext->data),
726                             PACKET_remaining(&currext->data),
727                             x, chainidx);
728 }
729
730 /*
731  * Parse all remaining extensions that have not yet been parsed. Also calls the
732  * finalisation for all extensions at the end if |fin| is nonzero, whether we
733  * collected them or not. Returns 1 for success or 0 for failure. If we are
734  * working on a Certificate message then we also pass the Certificate |x| and
735  * its position in the |chainidx|, with 0 being the first certificate.
736  */
737 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, X509 *x,
738                              size_t chainidx, int fin)
739 {
740     size_t i, numexts = OSSL_NELEM(ext_defs);
741     const EXTENSION_DEFINITION *thisexd;
742
743     /* Calculate the number of extensions in the extensions list */
744     numexts += s->cert->custext.meths_count;
745
746     /* Parse each extension in turn */
747     for (i = 0; i < numexts; i++) {
748         if (!tls_parse_extension(s, i, context, exts, x, chainidx)) {
749             /* SSLfatal() already called */
750             return 0;
751         }
752     }
753
754     if (fin) {
755         /*
756          * Finalise all known extensions relevant to this context,
757          * whether we have found them or not
758          */
759         for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs);
760              i++, thisexd++) {
761             if (thisexd->final != NULL && (thisexd->context & context) != 0
762                 && !thisexd->final(s, context, exts[i].present)) {
763                 /* SSLfatal() already called */
764                 return 0;
765             }
766         }
767     }
768
769     return 1;
770 }
771
772 int should_add_extension(SSL *s, unsigned int extctx, unsigned int thisctx,
773                          int max_version)
774 {
775     /* Skip if not relevant for our context */
776     if ((extctx & thisctx) == 0)
777         return 0;
778
779     /* Check if this extension is defined for our protocol. If not, skip */
780     if (!extension_is_relevant(s, extctx, thisctx)
781             || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
782                 && (thisctx & SSL_EXT_CLIENT_HELLO) != 0
783                 && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
784         return 0;
785
786     return 1;
787 }
788
789 /*
790  * Construct all the extensions relevant to the current |context| and write
791  * them to |pkt|. If this is an extension for a Certificate in a Certificate
792  * message, then |x| will be set to the Certificate we are handling, and
793  * |chainidx| will indicate the position in the chainidx we are processing (with
794  * 0 being the first in the chain). Returns 1 on success or 0 on failure. On a
795  * failure construction stops at the first extension to fail to construct.
796  */
797 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
798                              X509 *x, size_t chainidx)
799 {
800     size_t i;
801     int min_version, max_version = 0, reason;
802     const EXTENSION_DEFINITION *thisexd;
803
804     if (!WPACKET_start_sub_packet_u16(pkt)
805                /*
806                 * If extensions are of zero length then we don't even add the
807                 * extensions length bytes to a ClientHello/ServerHello
808                 * (for non-TLSv1.3).
809                 */
810             || ((context &
811                  (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0
812                 && !WPACKET_set_flags(pkt,
813                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
814         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
815                  ERR_R_INTERNAL_ERROR);
816         return 0;
817     }
818
819     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
820         reason = ssl_get_min_max_version(s, &min_version, &max_version, NULL);
821         if (reason != 0) {
822             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
823                      reason);
824             return 0;
825         }
826     }
827
828     /* Add custom extensions first */
829     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
830         /* On the server side with initialise during ClientHello parsing */
831         custom_ext_init(&s->cert->custext);
832     }
833     if (!custom_ext_add(s, context, pkt, x, chainidx, max_version)) {
834         /* SSLfatal() already called */
835         return 0;
836     }
837
838     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
839         EXT_RETURN (*construct)(SSL *s, WPACKET *pkt, unsigned int context,
840                                 X509 *x, size_t chainidx);
841         EXT_RETURN ret;
842
843         /* Skip if not relevant for our context */
844         if (!should_add_extension(s, thisexd->context, context, max_version))
845             continue;
846
847         construct = s->server ? thisexd->construct_stoc
848                               : thisexd->construct_ctos;
849
850         if (construct == NULL)
851             continue;
852
853         ret = construct(s, pkt, context, x, chainidx);
854         if (ret == EXT_RETURN_FAIL) {
855             /* SSLfatal() already called */
856             return 0;
857         }
858         if (ret == EXT_RETURN_SENT
859                 && (context & (SSL_EXT_CLIENT_HELLO
860                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
861                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0)
862             s->ext.extflags[i] |= SSL_EXT_FLAG_SENT;
863     }
864
865     if (!WPACKET_close(pkt)) {
866         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_EXTENSIONS,
867                  ERR_R_INTERNAL_ERROR);
868         return 0;
869     }
870
871     return 1;
872 }
873
874 /*
875  * Built in extension finalisation and initialisation functions. All initialise
876  * or finalise the associated extension type for the given |context|. For
877  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
878  * otherwise. These functions return 1 on success or 0 on failure.
879  */
880
881 static int final_renegotiate(SSL *s, unsigned int context, int sent)
882 {
883     if (!s->server) {
884         /*
885          * Check if we can connect to a server that doesn't support safe
886          * renegotiation
887          */
888         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
889                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
890                 && !sent) {
891             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_RENEGOTIATE,
892                      SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
893             return 0;
894         }
895
896         return 1;
897     }
898
899     /* Need RI if renegotiating */
900     if (s->renegotiate
901             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
902             && !sent) {
903         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_RENEGOTIATE,
904                  SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
905         return 0;
906     }
907
908
909     return 1;
910 }
911
912 static int init_server_name(SSL *s, unsigned int context)
913 {
914     if (s->server) {
915         s->servername_done = 0;
916
917         OPENSSL_free(s->ext.hostname);
918         s->ext.hostname = NULL;
919     }
920
921     return 1;
922 }
923
924 static int final_server_name(SSL *s, unsigned int context, int sent)
925 {
926     int ret = SSL_TLSEXT_ERR_NOACK;
927     int altmp = SSL_AD_UNRECOGNIZED_NAME;
928     int was_ticket = (SSL_get_options(s) & SSL_OP_NO_TICKET) == 0;
929
930     if (!ossl_assert(s->ctx != NULL) || !ossl_assert(s->session_ctx != NULL)) {
931         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
932                  ERR_R_INTERNAL_ERROR);
933         return 0;
934     }
935
936     if (s->ctx->ext.servername_cb != NULL)
937         ret = s->ctx->ext.servername_cb(s, &altmp,
938                                         s->ctx->ext.servername_arg);
939     else if (s->session_ctx->ext.servername_cb != NULL)
940         ret = s->session_ctx->ext.servername_cb(s, &altmp,
941                                        s->session_ctx->ext.servername_arg);
942
943     /*
944      * For servers, propagate the SNI hostname from the temporary
945      * storage in the SSL to the persistent SSL_SESSION, now that we
946      * know we accepted it.
947      * Clients make this copy when parsing the server's response to
948      * the extension, which is when they find out that the negotiation
949      * was successful.
950      */
951     if (s->server) {
952         /* TODO(OpenSSL1.2) revisit !sent case */
953         if (sent && ret == SSL_TLSEXT_ERR_OK && (!s->hit || SSL_IS_TLS13(s))) {
954             /* Only store the hostname in the session if we accepted it. */
955             OPENSSL_free(s->session->ext.hostname);
956             s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname);
957             if (s->session->ext.hostname == NULL && s->ext.hostname != NULL) {
958                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
959                          ERR_R_INTERNAL_ERROR);
960             }
961         }
962     }
963
964     /*
965      * If we switched contexts (whether here or in the client_hello callback),
966      * move the sess_accept increment from the session_ctx to the new
967      * context, to avoid the confusing situation of having sess_accept_good
968      * exceed sess_accept (zero) for the new context.
969      */
970     if (SSL_IS_FIRST_HANDSHAKE(s) && s->ctx != s->session_ctx) {
971         tsan_counter(&s->ctx->stats.sess_accept);
972         tsan_decr(&s->session_ctx->stats.sess_accept);
973     }
974
975     /*
976      * If we're expecting to send a ticket, and tickets were previously enabled,
977      * and now tickets are disabled, then turn off expected ticket.
978      * Also, if this is not a resumption, create a new session ID
979      */
980     if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected
981             && was_ticket && (SSL_get_options(s) & SSL_OP_NO_TICKET) != 0) {
982         s->ext.ticket_expected = 0;
983         if (!s->hit) {
984             SSL_SESSION* ss = SSL_get_session(s);
985
986             if (ss != NULL) {
987                 OPENSSL_free(ss->ext.tick);
988                 ss->ext.tick = NULL;
989                 ss->ext.ticklen = 0;
990                 ss->ext.tick_lifetime_hint = 0;
991                 ss->ext.tick_age_add = 0;
992                 if (!ssl_generate_session_id(s, ss)) {
993                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
994                              ERR_R_INTERNAL_ERROR);
995                     return 0;
996                 }
997             } else {
998                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
999                          ERR_R_INTERNAL_ERROR);
1000                 return 0;
1001             }
1002         }
1003     }
1004
1005     switch (ret) {
1006     case SSL_TLSEXT_ERR_ALERT_FATAL:
1007         SSLfatal(s, altmp, SSL_F_FINAL_SERVER_NAME, SSL_R_CALLBACK_FAILED);
1008         return 0;
1009
1010     case SSL_TLSEXT_ERR_ALERT_WARNING:
1011         /* TLSv1.3 doesn't have warning alerts so we suppress this */
1012         if (!SSL_IS_TLS13(s))
1013             ssl3_send_alert(s, SSL3_AL_WARNING, altmp);
1014         return 1;
1015
1016     case SSL_TLSEXT_ERR_NOACK:
1017         s->servername_done = 0;
1018         return 1;
1019
1020     default:
1021         return 1;
1022     }
1023 }
1024
1025 #ifndef OPENSSL_NO_EC
1026 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent)
1027 {
1028     unsigned long alg_k, alg_a;
1029
1030     if (s->server)
1031         return 1;
1032
1033     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1034     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1035
1036     /*
1037      * If we are client and using an elliptic curve cryptography cipher
1038      * suite, then if server returns an EC point formats lists extension it
1039      * must contain uncompressed.
1040      */
1041     if (s->ext.ecpointformats != NULL
1042             && s->ext.ecpointformats_len > 0
1043             && s->session->ext.ecpointformats != NULL
1044             && s->session->ext.ecpointformats_len > 0
1045             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
1046         /* we are using an ECC cipher */
1047         size_t i;
1048         unsigned char *list = s->session->ext.ecpointformats;
1049
1050         for (i = 0; i < s->session->ext.ecpointformats_len; i++) {
1051             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
1052                 break;
1053         }
1054         if (i == s->session->ext.ecpointformats_len) {
1055             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EC_PT_FORMATS,
1056                      SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1057             return 0;
1058         }
1059     }
1060
1061     return 1;
1062 }
1063 #endif
1064
1065 static int init_session_ticket(SSL *s, unsigned int context)
1066 {
1067     if (!s->server)
1068         s->ext.ticket_expected = 0;
1069
1070     return 1;
1071 }
1072
1073 #ifndef OPENSSL_NO_OCSP
1074 static int init_status_request(SSL *s, unsigned int context)
1075 {
1076     if (s->server) {
1077         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
1078     } else {
1079         /*
1080          * Ensure we get sensible values passed to tlsext_status_cb in the event
1081          * that we don't receive a status message
1082          */
1083         OPENSSL_free(s->ext.ocsp.resp);
1084         s->ext.ocsp.resp = NULL;
1085         s->ext.ocsp.resp_len = 0;
1086     }
1087
1088     return 1;
1089 }
1090 #endif
1091
1092 #ifndef OPENSSL_NO_NEXTPROTONEG
1093 static int init_npn(SSL *s, unsigned int context)
1094 {
1095     s->s3->npn_seen = 0;
1096
1097     return 1;
1098 }
1099 #endif
1100
1101 static int init_alpn(SSL *s, unsigned int context)
1102 {
1103     OPENSSL_free(s->s3->alpn_selected);
1104     s->s3->alpn_selected = NULL;
1105     s->s3->alpn_selected_len = 0;
1106     if (s->server) {
1107         OPENSSL_free(s->s3->alpn_proposed);
1108         s->s3->alpn_proposed = NULL;
1109         s->s3->alpn_proposed_len = 0;
1110     }
1111     return 1;
1112 }
1113
1114 static int final_alpn(SSL *s, unsigned int context, int sent)
1115 {
1116     if (!s->server && !sent && s->session->ext.alpn_selected != NULL)
1117             s->ext.early_data_ok = 0;
1118
1119     if (!s->server || !SSL_IS_TLS13(s))
1120         return 1;
1121
1122     /*
1123      * Call alpn_select callback if needed.  Has to be done after SNI and
1124      * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3
1125      * we also have to do this before we decide whether to accept early_data.
1126      * In TLSv1.3 we've already negotiated our cipher so we do this call now.
1127      * For < TLSv1.3 we defer it until after cipher negotiation.
1128      *
1129      * On failure SSLfatal() already called.
1130      */
1131     return tls_handle_alpn(s);
1132 }
1133
1134 static int init_sig_algs(SSL *s, unsigned int context)
1135 {
1136     /* Clear any signature algorithms extension received */
1137     OPENSSL_free(s->s3->tmp.peer_sigalgs);
1138     s->s3->tmp.peer_sigalgs = NULL;
1139
1140     return 1;
1141 }
1142
1143 static int init_sig_algs_cert(SSL *s, unsigned int context)
1144 {
1145     /* Clear any signature algorithms extension received */
1146     OPENSSL_free(s->s3->tmp.peer_cert_sigalgs);
1147     s->s3->tmp.peer_cert_sigalgs = NULL;
1148
1149     return 1;
1150 }
1151
1152 #ifndef OPENSSL_NO_SRP
1153 static int init_srp(SSL *s, unsigned int context)
1154 {
1155     OPENSSL_free(s->srp_ctx.login);
1156     s->srp_ctx.login = NULL;
1157
1158     return 1;
1159 }
1160 #endif
1161
1162 static int init_etm(SSL *s, unsigned int context)
1163 {
1164     s->ext.use_etm = 0;
1165
1166     return 1;
1167 }
1168
1169 static int init_ems(SSL *s, unsigned int context)
1170 {
1171     if (!s->server)
1172         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1173
1174     return 1;
1175 }
1176
1177 static int final_ems(SSL *s, unsigned int context, int sent)
1178 {
1179     if (!s->server && s->hit) {
1180         /*
1181          * Check extended master secret extension is consistent with
1182          * original session.
1183          */
1184         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1185             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1186             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_EMS,
1187                      SSL_R_INCONSISTENT_EXTMS);
1188             return 0;
1189         }
1190     }
1191
1192     return 1;
1193 }
1194
1195 static int init_certificate_authorities(SSL *s, unsigned int context)
1196 {
1197     sk_X509_NAME_pop_free(s->s3->tmp.peer_ca_names, X509_NAME_free);
1198     s->s3->tmp.peer_ca_names = NULL;
1199     return 1;
1200 }
1201
1202 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
1203                                                         unsigned int context,
1204                                                         X509 *x,
1205                                                         size_t chainidx)
1206 {
1207     const STACK_OF(X509_NAME) *ca_sk = get_ca_names(s);
1208
1209     if (ca_sk == NULL || sk_X509_NAME_num(ca_sk) == 0)
1210         return EXT_RETURN_NOT_SENT;
1211
1212     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities)
1213         || !WPACKET_start_sub_packet_u16(pkt)) {
1214         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1215                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1216                ERR_R_INTERNAL_ERROR);
1217         return EXT_RETURN_FAIL;
1218     }
1219
1220     if (!construct_ca_names(s, ca_sk, pkt)) {
1221         /* SSLfatal() already called */
1222         return EXT_RETURN_FAIL;
1223     }
1224
1225     if (!WPACKET_close(pkt)) {
1226         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1227                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1228                  ERR_R_INTERNAL_ERROR);
1229         return EXT_RETURN_FAIL;
1230     }
1231
1232     return EXT_RETURN_SENT;
1233 }
1234
1235 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
1236                                              unsigned int context, X509 *x,
1237                                              size_t chainidx)
1238 {
1239     if (!parse_ca_names(s, pkt))
1240         return 0;
1241     if (PACKET_remaining(pkt) != 0) {
1242         SSLfatal(s, SSL_AD_DECODE_ERROR,
1243                  SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES, SSL_R_BAD_EXTENSION);
1244         return 0;
1245     }
1246     return 1;
1247 }
1248
1249 #ifndef OPENSSL_NO_SRTP
1250 static int init_srtp(SSL *s, unsigned int context)
1251 {
1252     if (s->server)
1253         s->srtp_profile = NULL;
1254
1255     return 1;
1256 }
1257 #endif
1258
1259 static int final_sig_algs(SSL *s, unsigned int context, int sent)
1260 {
1261     if (!sent && SSL_IS_TLS13(s) && !s->hit) {
1262         SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_F_FINAL_SIG_ALGS,
1263                  SSL_R_MISSING_SIGALGS_EXTENSION);
1264         return 0;
1265     }
1266
1267     return 1;
1268 }
1269
1270 #ifndef OPENSSL_NO_EC
1271 static int final_key_share(SSL *s, unsigned int context, int sent)
1272 {
1273     if (!SSL_IS_TLS13(s))
1274         return 1;
1275
1276     /* Nothing to do for key_share in an HRR */
1277     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
1278         return 1;
1279
1280     /*
1281      * If
1282      *     we are a client
1283      *     AND
1284      *     we have no key_share
1285      *     AND
1286      *     (we are not resuming
1287      *      OR the kex_mode doesn't allow non key_share resumes)
1288      * THEN
1289      *     fail;
1290      */
1291     if (!s->server
1292             && !sent
1293             && (!s->hit
1294                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) {
1295         /* Nothing left we can do - just fail */
1296         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_KEY_SHARE,
1297                  SSL_R_NO_SUITABLE_KEY_SHARE);
1298         return 0;
1299     }
1300     /*
1301      * IF
1302      *     we are a server
1303      * THEN
1304      *     IF
1305      *         we have a suitable key_share
1306      *     THEN
1307      *         IF
1308      *             we are stateless AND we have no cookie
1309      *         THEN
1310      *             send a HelloRetryRequest
1311      *     ELSE
1312      *         IF
1313      *             we didn't already send a HelloRetryRequest
1314      *             AND
1315      *             the client sent a key_share extension
1316      *             AND
1317      *             (we are not resuming
1318      *              OR the kex_mode allows key_share resumes)
1319      *             AND
1320      *             a shared group exists
1321      *         THEN
1322      *             send a HelloRetryRequest
1323      *         ELSE IF
1324      *             we are not resuming
1325      *             OR
1326      *             the kex_mode doesn't allow non key_share resumes
1327      *         THEN
1328      *             fail
1329      *         ELSE IF
1330      *             we are stateless AND we have no cookie
1331      *         THEN
1332      *             send a HelloRetryRequest
1333      */
1334     if (s->server) {
1335         if (s->s3->peer_tmp != NULL) {
1336             /* We have a suitable key_share */
1337             if ((s->s3->flags & TLS1_FLAGS_STATELESS) != 0
1338                     && !s->ext.cookieok) {
1339                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1340                     /*
1341                      * If we are stateless then we wouldn't know about any
1342                      * previously sent HRR - so how can this be anything other
1343                      * than 0?
1344                      */
1345                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1346                              ERR_R_INTERNAL_ERROR);
1347                     return 0;
1348                 }
1349                 s->hello_retry_request = SSL_HRR_PENDING;
1350                 return 1;
1351             }
1352         } else {
1353             /* No suitable key_share */
1354             if (s->hello_retry_request == SSL_HRR_NONE && sent
1355                     && (!s->hit
1356                         || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE)
1357                            != 0)) {
1358                 const uint16_t *pgroups, *clntgroups;
1359                 size_t num_groups, clnt_num_groups, i;
1360                 unsigned int group_id = 0;
1361
1362                 /* Check if a shared group exists */
1363
1364                 /* Get the clients list of supported groups. */
1365                 tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups);
1366                 tls1_get_supported_groups(s, &pgroups, &num_groups);
1367
1368                 /*
1369                  * Find the first group we allow that is also in client's list
1370                  */
1371                 for (i = 0; i < num_groups; i++) {
1372                     group_id = pgroups[i];
1373
1374                     if (check_in_list(s, group_id, clntgroups, clnt_num_groups,
1375                                       1))
1376                         break;
1377                 }
1378
1379                 if (i < num_groups) {
1380                     /* A shared group exists so send a HelloRetryRequest */
1381                     s->s3->group_id = group_id;
1382                     s->hello_retry_request = SSL_HRR_PENDING;
1383                     return 1;
1384                 }
1385             }
1386             if (!s->hit
1387                     || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
1388                 /* Nothing left we can do - just fail */
1389                 SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE
1390                                  : SSL_AD_MISSING_EXTENSION,
1391                          SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
1392                 return 0;
1393             }
1394
1395             if ((s->s3->flags & TLS1_FLAGS_STATELESS) != 0
1396                     && !s->ext.cookieok) {
1397                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1398                     /*
1399                      * If we are stateless then we wouldn't know about any
1400                      * previously sent HRR - so how can this be anything other
1401                      * than 0?
1402                      */
1403                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1404                              ERR_R_INTERNAL_ERROR);
1405                     return 0;
1406                 }
1407                 s->hello_retry_request = SSL_HRR_PENDING;
1408                 return 1;
1409             }
1410         }
1411
1412         /*
1413          * We have a key_share so don't send any more HelloRetryRequest
1414          * messages
1415          */
1416         if (s->hello_retry_request == SSL_HRR_PENDING)
1417             s->hello_retry_request = SSL_HRR_COMPLETE;
1418     } else {
1419         /*
1420          * For a client side resumption with no key_share we need to generate
1421          * the handshake secret (otherwise this is done during key_share
1422          * processing).
1423          */
1424         if (!sent && !tls13_generate_handshake_secret(s, NULL, 0)) {
1425             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1426                      ERR_R_INTERNAL_ERROR);
1427             return 0;
1428         }
1429     }
1430
1431     return 1;
1432 }
1433 #endif
1434
1435 static int init_psk_kex_modes(SSL *s, unsigned int context)
1436 {
1437     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
1438     return 1;
1439 }
1440
1441 int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
1442                       size_t binderoffset, const unsigned char *binderin,
1443                       unsigned char *binderout, SSL_SESSION *sess, int sign,
1444                       int external)
1445 {
1446     EVP_PKEY *mackey = NULL;
1447     EVP_MD_CTX *mctx = NULL;
1448     unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE];
1449     unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE];
1450     unsigned char *early_secret;
1451     static const unsigned char resumption_label[] = "res binder";
1452     static const unsigned char external_label[] = "ext binder";
1453     const unsigned char *label;
1454     size_t bindersize, labelsize, hashsize;
1455     int hashsizei = EVP_MD_size(md);
1456     int ret = -1;
1457     int usepskfored = 0;
1458
1459     /* Ensure cast to size_t is safe */
1460     if (!ossl_assert(hashsizei >= 0)) {
1461         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1462                  ERR_R_INTERNAL_ERROR);
1463         goto err;
1464     }
1465     hashsize = (size_t)hashsizei;
1466
1467     if (external
1468             && s->early_data_state == SSL_EARLY_DATA_CONNECTING
1469             && s->session->ext.max_early_data == 0
1470             && sess->ext.max_early_data > 0)
1471         usepskfored = 1;
1472
1473     if (external) {
1474         label = external_label;
1475         labelsize = sizeof(external_label) - 1;
1476     } else {
1477         label = resumption_label;
1478         labelsize = sizeof(resumption_label) - 1;
1479     }
1480
1481     /*
1482      * Generate the early_secret. On the server side we've selected a PSK to
1483      * resume with (internal or external) so we always do this. On the client
1484      * side we do this for a non-external (i.e. resumption) PSK or external PSK
1485      * that will be used for early_data so that it is in place for sending early
1486      * data. For client side external PSK not being used for early_data we
1487      * generate it but store it away for later use.
1488      */
1489     if (s->server || !external || usepskfored)
1490         early_secret = (unsigned char *)s->early_secret;
1491     else
1492         early_secret = (unsigned char *)sess->early_secret;
1493
1494     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
1495                                sess->master_key_length, early_secret)) {
1496         /* SSLfatal() already called */
1497         goto err;
1498     }
1499
1500     /*
1501      * Create the handshake hash for the binder key...the messages so far are
1502      * empty!
1503      */
1504     mctx = EVP_MD_CTX_new();
1505     if (mctx == NULL
1506             || EVP_DigestInit_ex(mctx, md, NULL) <= 0
1507             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1508         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1509                  ERR_R_INTERNAL_ERROR);
1510         goto err;
1511     }
1512
1513     /* Generate the binder key */
1514     if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash,
1515                            hashsize, binderkey, hashsize, 1)) {
1516         /* SSLfatal() already called */
1517         goto err;
1518     }
1519
1520     /* Generate the finished key */
1521     if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) {
1522         /* SSLfatal() already called */
1523         goto err;
1524     }
1525
1526     if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) {
1527         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1528                  ERR_R_INTERNAL_ERROR);
1529         goto err;
1530     }
1531
1532     /*
1533      * Get a hash of the ClientHello up to the start of the binders. If we are
1534      * following a HelloRetryRequest then this includes the hash of the first
1535      * ClientHello and the HelloRetryRequest itself.
1536      */
1537     if (s->hello_retry_request == SSL_HRR_PENDING) {
1538         size_t hdatalen;
1539         long hdatalen_l;
1540         void *hdata;
1541
1542         hdatalen = hdatalen_l =
1543             BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
1544         if (hdatalen_l <= 0) {
1545             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1546                      SSL_R_BAD_HANDSHAKE_LENGTH);
1547             goto err;
1548         }
1549
1550         /*
1551          * For servers the handshake buffer data will include the second
1552          * ClientHello - which we don't want - so we need to take that bit off.
1553          */
1554         if (s->server) {
1555             PACKET hashprefix, msg;
1556
1557             /* Find how many bytes are left after the first two messages */
1558             if (!PACKET_buf_init(&hashprefix, hdata, hdatalen)
1559                     || !PACKET_forward(&hashprefix, 1)
1560                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
1561                     || !PACKET_forward(&hashprefix, 1)
1562                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
1563                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1564                          ERR_R_INTERNAL_ERROR);
1565                 goto err;
1566             }
1567             hdatalen -= PACKET_remaining(&hashprefix);
1568         }
1569
1570         if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) {
1571             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1572                      ERR_R_INTERNAL_ERROR);
1573             goto err;
1574         }
1575     }
1576
1577     if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
1578             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1579         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1580                  ERR_R_INTERNAL_ERROR);
1581         goto err;
1582     }
1583
1584     mackey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, finishedkey,
1585                                           hashsize);
1586     if (mackey == NULL) {
1587         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1588                  ERR_R_INTERNAL_ERROR);
1589         goto err;
1590     }
1591
1592     if (!sign)
1593         binderout = tmpbinder;
1594
1595     bindersize = hashsize;
1596     if (EVP_DigestSignInit(mctx, NULL, md, NULL, mackey) <= 0
1597             || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
1598             || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
1599             || bindersize != hashsize) {
1600         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1601                  ERR_R_INTERNAL_ERROR);
1602         goto err;
1603     }
1604
1605     if (sign) {
1606         ret = 1;
1607     } else {
1608         /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */
1609         ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0);
1610         if (!ret)
1611             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PSK_DO_BINDER,
1612                      SSL_R_BINDER_DOES_NOT_VERIFY);
1613     }
1614
1615  err:
1616     OPENSSL_cleanse(binderkey, sizeof(binderkey));
1617     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
1618     EVP_PKEY_free(mackey);
1619     EVP_MD_CTX_free(mctx);
1620
1621     return ret;
1622 }
1623
1624 static int final_early_data(SSL *s, unsigned int context, int sent)
1625 {
1626     if (!sent)
1627         return 1;
1628
1629     if (!s->server) {
1630         if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1631                 && sent
1632                 && !s->ext.early_data_ok) {
1633             /*
1634              * If we get here then the server accepted our early_data but we
1635              * later realised that it shouldn't have done (e.g. inconsistent
1636              * ALPN)
1637              */
1638             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EARLY_DATA,
1639                      SSL_R_BAD_EARLY_DATA);
1640             return 0;
1641         }
1642
1643         return 1;
1644     }
1645
1646     if (s->max_early_data == 0
1647             || !s->hit
1648             || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
1649             || !s->ext.early_data_ok
1650             || s->hello_retry_request != SSL_HRR_NONE
1651             || (s->ctx->allow_early_data_cb != NULL
1652                 && !s->ctx->allow_early_data_cb(s,
1653                                          s->ctx->allow_early_data_cb_data))) {
1654         s->ext.early_data = SSL_EARLY_DATA_REJECTED;
1655     } else {
1656         s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1657
1658         if (!tls13_change_cipher_state(s,
1659                     SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
1660             /* SSLfatal() already called */
1661             return 0;
1662         }
1663     }
1664
1665     return 1;
1666 }
1667
1668 static int final_maxfragmentlen(SSL *s, unsigned int context, int sent)
1669 {
1670     /*
1671      * Session resumption on server-side with MFL extension active
1672      *  BUT MFL extension packet was not resent (i.e. sent == 0)
1673      */
1674     if (s->server && s->hit && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1675             && !sent ) {
1676         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_MAXFRAGMENTLEN,
1677                  SSL_R_BAD_EXTENSION);
1678         return 0;
1679     }
1680
1681     /* Current SSL buffer is lower than requested MFL */
1682     if (s->session && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1683             && s->max_send_fragment < GET_MAX_FRAGMENT_LENGTH(s->session))
1684         /* trigger a larger buffer reallocation */
1685         if (!ssl3_setup_buffers(s)) {
1686             /* SSLfatal() already called */
1687             return 0;
1688         }
1689
1690     return 1;
1691 }
1692
1693 static int init_post_handshake_auth(SSL *s, unsigned int context)
1694 {
1695     s->post_handshake_auth = SSL_PHA_NONE;
1696
1697     return 1;
1698 }