cd4f078cf3d80622bf83a807e3b5f22534e4080e
[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, NULL);
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;
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     /*
933      * For servers, propagate the SNI hostname from the temporary
934      * storage in the SSL to the persistent SSL_SESSION, now that we
935      * know we accepted it.
936      * Clients make this copy when parsing the server's response to
937      * the extension, which is when they find out that the negotiation
938      * was successful.
939      */
940     if (s->server) {
941         /* TODO(OpenSSL1.2) revisit !sent case */
942         if (sent && ret == SSL_TLSEXT_ERR_OK && (!s->hit || SSL_IS_TLS13(s))) {
943             /* Only store the hostname in the session if we accepted it. */
944             OPENSSL_free(s->session->ext.hostname);
945             s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname);
946             if (s->session->ext.hostname == NULL && s->ext.hostname != NULL) {
947                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
948                          ERR_R_INTERNAL_ERROR);
949             }
950         }
951     }
952
953     /*
954      * If we switched contexts (whether here or in the client_hello callback),
955      * move the sess_accept increment from the session_ctx to the new
956      * context, to avoid the confusing situation of having sess_accept_good
957      * exceed sess_accept (zero) for the new context.
958      */
959     if (SSL_IS_FIRST_HANDSHAKE(s) && s->ctx != s->session_ctx) {
960         tsan_counter(&s->ctx->stats.sess_accept);
961         tsan_counter(&s->session_ctx->stats.sess_accept);
962     }
963
964     /*
965      * If we're expecting to send a ticket, and tickets were previously enabled,
966      * and now tickets are disabled, then turn off expected ticket.
967      * Also, if this is not a resumption, create a new session ID
968      */
969     if (ret == SSL_TLSEXT_ERR_OK && s->ext.ticket_expected
970             && was_ticket && (SSL_get_options(s) & SSL_OP_NO_TICKET) != 0) {
971         s->ext.ticket_expected = 0;
972         if (!s->hit) {
973             SSL_SESSION* ss = SSL_get_session(s);
974
975             if (ss != NULL) {
976                 OPENSSL_free(ss->ext.tick);
977                 ss->ext.tick = NULL;
978                 ss->ext.ticklen = 0;
979                 ss->ext.tick_lifetime_hint = 0;
980                 ss->ext.tick_age_add = 0;
981                 ss->ext.tick_identity = 0;
982                 if (!ssl_generate_session_id(s, ss)) {
983                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
984                              ERR_R_INTERNAL_ERROR);
985                     return 0;
986                 }
987             } else {
988                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_SERVER_NAME,
989                          ERR_R_INTERNAL_ERROR);
990                 return 0;
991             }
992         }
993     }
994
995     switch (ret) {
996     case SSL_TLSEXT_ERR_ALERT_FATAL:
997         SSLfatal(s, altmp, SSL_F_FINAL_SERVER_NAME, SSL_R_CALLBACK_FAILED);
998         return 0;
999
1000     case SSL_TLSEXT_ERR_ALERT_WARNING:
1001         /* TLSv1.3 doesn't have warning alerts so we suppress this */
1002         if (!SSL_IS_TLS13(s))
1003             ssl3_send_alert(s, SSL3_AL_WARNING, altmp);
1004         return 1;
1005
1006     case SSL_TLSEXT_ERR_NOACK:
1007         s->servername_done = 0;
1008         return 1;
1009
1010     default:
1011         return 1;
1012     }
1013 }
1014
1015 #ifndef OPENSSL_NO_EC
1016 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent)
1017 {
1018     unsigned long alg_k, alg_a;
1019
1020     if (s->server)
1021         return 1;
1022
1023     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1024     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1025
1026     /*
1027      * If we are client and using an elliptic curve cryptography cipher
1028      * suite, then if server returns an EC point formats lists extension it
1029      * must contain uncompressed.
1030      */
1031     if (s->ext.ecpointformats != NULL
1032             && s->ext.ecpointformats_len > 0
1033             && s->session->ext.ecpointformats != NULL
1034             && s->session->ext.ecpointformats_len > 0
1035             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
1036         /* we are using an ECC cipher */
1037         size_t i;
1038         unsigned char *list = s->session->ext.ecpointformats;
1039
1040         for (i = 0; i < s->session->ext.ecpointformats_len; i++) {
1041             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
1042                 break;
1043         }
1044         if (i == s->session->ext.ecpointformats_len) {
1045             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EC_PT_FORMATS,
1046                      SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1047             return 0;
1048         }
1049     }
1050
1051     return 1;
1052 }
1053 #endif
1054
1055 static int init_session_ticket(SSL *s, unsigned int context)
1056 {
1057     if (!s->server)
1058         s->ext.ticket_expected = 0;
1059
1060     return 1;
1061 }
1062
1063 #ifndef OPENSSL_NO_OCSP
1064 static int init_status_request(SSL *s, unsigned int context)
1065 {
1066     if (s->server) {
1067         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
1068     } else {
1069         /*
1070          * Ensure we get sensible values passed to tlsext_status_cb in the event
1071          * that we don't receive a status message
1072          */
1073         OPENSSL_free(s->ext.ocsp.resp);
1074         s->ext.ocsp.resp = NULL;
1075         s->ext.ocsp.resp_len = 0;
1076     }
1077
1078     return 1;
1079 }
1080 #endif
1081
1082 #ifndef OPENSSL_NO_NEXTPROTONEG
1083 static int init_npn(SSL *s, unsigned int context)
1084 {
1085     s->s3->npn_seen = 0;
1086
1087     return 1;
1088 }
1089 #endif
1090
1091 static int init_alpn(SSL *s, unsigned int context)
1092 {
1093     OPENSSL_free(s->s3->alpn_selected);
1094     s->s3->alpn_selected = NULL;
1095     s->s3->alpn_selected_len = 0;
1096     if (s->server) {
1097         OPENSSL_free(s->s3->alpn_proposed);
1098         s->s3->alpn_proposed = NULL;
1099         s->s3->alpn_proposed_len = 0;
1100     }
1101     return 1;
1102 }
1103
1104 static int final_alpn(SSL *s, unsigned int context, int sent)
1105 {
1106     if (!s->server && !sent && s->session->ext.alpn_selected != NULL)
1107             s->ext.early_data_ok = 0;
1108
1109     if (!s->server || !SSL_IS_TLS13(s))
1110         return 1;
1111
1112     /*
1113      * Call alpn_select callback if needed.  Has to be done after SNI and
1114      * cipher negotiation (HTTP/2 restricts permitted ciphers). In TLSv1.3
1115      * we also have to do this before we decide whether to accept early_data.
1116      * In TLSv1.3 we've already negotiated our cipher so we do this call now.
1117      * For < TLSv1.3 we defer it until after cipher negotiation.
1118      *
1119      * On failure SSLfatal() already called.
1120      */
1121     return tls_handle_alpn(s);
1122 }
1123
1124 static int init_sig_algs(SSL *s, unsigned int context)
1125 {
1126     /* Clear any signature algorithms extension received */
1127     OPENSSL_free(s->s3->tmp.peer_sigalgs);
1128     s->s3->tmp.peer_sigalgs = NULL;
1129
1130     return 1;
1131 }
1132
1133 static int init_sig_algs_cert(SSL *s, unsigned int context)
1134 {
1135     /* Clear any signature algorithms extension received */
1136     OPENSSL_free(s->s3->tmp.peer_cert_sigalgs);
1137     s->s3->tmp.peer_cert_sigalgs = NULL;
1138
1139     return 1;
1140 }
1141
1142 #ifndef OPENSSL_NO_SRP
1143 static int init_srp(SSL *s, unsigned int context)
1144 {
1145     OPENSSL_free(s->srp_ctx.login);
1146     s->srp_ctx.login = NULL;
1147
1148     return 1;
1149 }
1150 #endif
1151
1152 static int init_etm(SSL *s, unsigned int context)
1153 {
1154     s->ext.use_etm = 0;
1155
1156     return 1;
1157 }
1158
1159 static int init_ems(SSL *s, unsigned int context)
1160 {
1161     if (!s->server)
1162         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1163
1164     return 1;
1165 }
1166
1167 static int final_ems(SSL *s, unsigned int context, int sent)
1168 {
1169     if (!s->server && s->hit) {
1170         /*
1171          * Check extended master secret extension is consistent with
1172          * original session.
1173          */
1174         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1175             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1176             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_FINAL_EMS,
1177                      SSL_R_INCONSISTENT_EXTMS);
1178             return 0;
1179         }
1180     }
1181
1182     return 1;
1183 }
1184
1185 static int init_certificate_authorities(SSL *s, unsigned int context)
1186 {
1187     sk_X509_NAME_pop_free(s->s3->tmp.peer_ca_names, X509_NAME_free);
1188     s->s3->tmp.peer_ca_names = NULL;
1189     return 1;
1190 }
1191
1192 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
1193                                                         unsigned int context,
1194                                                         X509 *x,
1195                                                         size_t chainidx)
1196 {
1197     const STACK_OF(X509_NAME) *ca_sk = SSL_get0_CA_list(s);
1198
1199     if (ca_sk == NULL || sk_X509_NAME_num(ca_sk) == 0)
1200         return EXT_RETURN_NOT_SENT;
1201
1202     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities)
1203         || !WPACKET_start_sub_packet_u16(pkt)) {
1204         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1205                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1206                ERR_R_INTERNAL_ERROR);
1207         return EXT_RETURN_FAIL;
1208     }
1209
1210     if (!construct_ca_names(s, pkt)) {
1211         /* SSLfatal() already called */
1212         return EXT_RETURN_FAIL;
1213     }
1214
1215     if (!WPACKET_close(pkt)) {
1216         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1217                  SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1218                  ERR_R_INTERNAL_ERROR);
1219         return EXT_RETURN_FAIL;
1220     }
1221
1222     return EXT_RETURN_SENT;
1223 }
1224
1225 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
1226                                              unsigned int context, X509 *x,
1227                                              size_t chainidx)
1228 {
1229     if (!parse_ca_names(s, pkt))
1230         return 0;
1231     if (PACKET_remaining(pkt) != 0) {
1232         SSLfatal(s, SSL_AD_DECODE_ERROR,
1233                  SSL_F_TLS_PARSE_CERTIFICATE_AUTHORITIES, SSL_R_BAD_EXTENSION);
1234         return 0;
1235     }
1236     return 1;
1237 }
1238
1239 #ifndef OPENSSL_NO_SRTP
1240 static int init_srtp(SSL *s, unsigned int context)
1241 {
1242     if (s->server)
1243         s->srtp_profile = NULL;
1244
1245     return 1;
1246 }
1247 #endif
1248
1249 static int final_sig_algs(SSL *s, unsigned int context, int sent)
1250 {
1251     if (!sent && SSL_IS_TLS13(s) && !s->hit) {
1252         SSLfatal(s, TLS13_AD_MISSING_EXTENSION, SSL_F_FINAL_SIG_ALGS,
1253                  SSL_R_MISSING_SIGALGS_EXTENSION);
1254         return 0;
1255     }
1256
1257     return 1;
1258 }
1259
1260 #ifndef OPENSSL_NO_EC
1261 static int final_key_share(SSL *s, unsigned int context, int sent)
1262 {
1263     if (!SSL_IS_TLS13(s))
1264         return 1;
1265
1266     /* Nothing to do for key_share in an HRR */
1267     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
1268         return 1;
1269
1270     /*
1271      * If
1272      *     we are a client
1273      *     AND
1274      *     we have no key_share
1275      *     AND
1276      *     (we are not resuming
1277      *      OR the kex_mode doesn't allow non key_share resumes)
1278      * THEN
1279      *     fail;
1280      */
1281     if (!s->server
1282             && !sent
1283             && (!s->hit
1284                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) {
1285         /* Nothing left we can do - just fail */
1286         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_KEY_SHARE,
1287                  SSL_R_NO_SUITABLE_KEY_SHARE);
1288         return 0;
1289     }
1290     /*
1291      * IF
1292      *     we are a server
1293      * THEN
1294      *     IF
1295      *         we have a suitable key_share
1296      *     THEN
1297      *         IF
1298      *             we are stateless AND we have no cookie
1299      *         THEN
1300      *             send a HelloRetryRequest
1301      *     ELSE
1302      *         IF
1303      *             we didn't already send a HelloRetryRequest
1304      *             AND
1305      *             the client sent a key_share extension
1306      *             AND
1307      *             (we are not resuming
1308      *              OR the kex_mode allows key_share resumes)
1309      *             AND
1310      *             a shared group exists
1311      *         THEN
1312      *             send a HelloRetryRequest
1313      *         ELSE IF
1314      *             we are not resuming
1315      *             OR
1316      *             the kex_mode doesn't allow non key_share resumes
1317      *         THEN
1318      *             fail
1319      *         ELSE IF
1320      *             we are stateless AND we have no cookie
1321      *         THEN
1322      *             send a HelloRetryRequest
1323      */
1324     if (s->server) {
1325         if (s->s3->peer_tmp != NULL) {
1326             /* We have a suitable key_share */
1327             if ((s->s3->flags & TLS1_FLAGS_STATELESS) != 0
1328                     && !s->ext.cookieok) {
1329                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1330                     /*
1331                      * If we are stateless then we wouldn't know about any
1332                      * previously sent HRR - so how can this be anything other
1333                      * than 0?
1334                      */
1335                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1336                              ERR_R_INTERNAL_ERROR);
1337                     return 0;
1338                 }
1339                 s->hello_retry_request = SSL_HRR_PENDING;
1340                 return 1;
1341             }
1342         } else {
1343             /* No suitable key_share */
1344             if (s->hello_retry_request == SSL_HRR_NONE && sent
1345                     && (!s->hit
1346                         || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE)
1347                            != 0)) {
1348                 const uint16_t *pgroups, *clntgroups;
1349                 size_t num_groups, clnt_num_groups, i;
1350                 unsigned int group_id = 0;
1351
1352                 /* Check if a shared group exists */
1353
1354                 /* Get the clients list of supported groups. */
1355                 tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups);
1356                 tls1_get_supported_groups(s, &pgroups, &num_groups);
1357
1358                 /*
1359                  * Find the first group we allow that is also in client's list
1360                  */
1361                 for (i = 0; i < num_groups; i++) {
1362                     group_id = pgroups[i];
1363
1364                     if (check_in_list(s, group_id, clntgroups, clnt_num_groups,
1365                                       1))
1366                         break;
1367                 }
1368
1369                 if (i < num_groups) {
1370                     /* A shared group exists so send a HelloRetryRequest */
1371                     s->s3->group_id = group_id;
1372                     s->hello_retry_request = SSL_HRR_PENDING;
1373                     return 1;
1374                 }
1375             }
1376             if (!s->hit
1377                     || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
1378                 /* Nothing left we can do - just fail */
1379                 SSLfatal(s, sent ? SSL_AD_HANDSHAKE_FAILURE
1380                                  : SSL_AD_MISSING_EXTENSION,
1381                          SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
1382                 return 0;
1383             }
1384
1385             if ((s->s3->flags & TLS1_FLAGS_STATELESS) != 0
1386                     && !s->ext.cookieok) {
1387                 if (!ossl_assert(s->hello_retry_request == SSL_HRR_NONE)) {
1388                     /*
1389                      * If we are stateless then we wouldn't know about any
1390                      * previously sent HRR - so how can this be anything other
1391                      * than 0?
1392                      */
1393                     SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1394                              ERR_R_INTERNAL_ERROR);
1395                     return 0;
1396                 }
1397                 s->hello_retry_request = SSL_HRR_PENDING;
1398                 return 1;
1399             }
1400         }
1401
1402         /*
1403          * We have a key_share so don't send any more HelloRetryRequest
1404          * messages
1405          */
1406         if (s->hello_retry_request == SSL_HRR_PENDING)
1407             s->hello_retry_request = SSL_HRR_COMPLETE;
1408     } else {
1409         /*
1410          * For a client side resumption with no key_share we need to generate
1411          * the handshake secret (otherwise this is done during key_share
1412          * processing).
1413          */
1414         if (!sent && !tls13_generate_handshake_secret(s, NULL, 0)) {
1415             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_FINAL_KEY_SHARE,
1416                      ERR_R_INTERNAL_ERROR);
1417             return 0;
1418         }
1419     }
1420
1421     return 1;
1422 }
1423 #endif
1424
1425 static int init_psk_kex_modes(SSL *s, unsigned int context)
1426 {
1427     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
1428     return 1;
1429 }
1430
1431 int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
1432                       size_t binderoffset, const unsigned char *binderin,
1433                       unsigned char *binderout, SSL_SESSION *sess, int sign,
1434                       int external)
1435 {
1436     EVP_PKEY *mackey = NULL;
1437     EVP_MD_CTX *mctx = NULL;
1438     unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE];
1439     unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE];
1440     unsigned char *early_secret;
1441     static const unsigned char resumption_label[] = "res binder";
1442     static const unsigned char external_label[] = "ext binder";
1443     const unsigned char *label;
1444     size_t bindersize, labelsize, hashsize;
1445     int hashsizei = EVP_MD_size(md);
1446     int ret = -1;
1447     int usepskfored = 0;
1448
1449     /* Ensure cast to size_t is safe */
1450     if (!ossl_assert(hashsizei >= 0)) {
1451         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1452                  ERR_R_INTERNAL_ERROR);
1453         goto err;
1454     }
1455     hashsize = (size_t)hashsizei;
1456
1457     if (external
1458             && s->early_data_state == SSL_EARLY_DATA_CONNECTING
1459             && s->session->ext.max_early_data == 0
1460             && sess->ext.max_early_data > 0)
1461         usepskfored = 1;
1462
1463     if (external) {
1464         label = external_label;
1465         labelsize = sizeof(external_label) - 1;
1466     } else {
1467         label = resumption_label;
1468         labelsize = sizeof(resumption_label) - 1;
1469     }
1470
1471     /*
1472      * Generate the early_secret. On the server side we've selected a PSK to
1473      * resume with (internal or external) so we always do this. On the client
1474      * side we do this for a non-external (i.e. resumption) PSK or external PSK
1475      * that will be used for early_data so that it is in place for sending early
1476      * data. For client side external PSK not being used for early_data we
1477      * generate it but store it away for later use.
1478      */
1479     if (s->server || !external || usepskfored)
1480         early_secret = (unsigned char *)s->early_secret;
1481     else
1482         early_secret = (unsigned char *)sess->early_secret;
1483
1484     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
1485                                sess->master_key_length, early_secret)) {
1486         /* SSLfatal() already called */
1487         goto err;
1488     }
1489
1490     /*
1491      * Create the handshake hash for the binder key...the messages so far are
1492      * empty!
1493      */
1494     mctx = EVP_MD_CTX_new();
1495     if (mctx == NULL
1496             || EVP_DigestInit_ex(mctx, md, NULL) <= 0
1497             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1498         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1499                  ERR_R_INTERNAL_ERROR);
1500         goto err;
1501     }
1502
1503     /* Generate the binder key */
1504     if (!tls13_hkdf_expand(s, md, early_secret, label, labelsize, hash,
1505                            hashsize, binderkey, hashsize)) {
1506         /* SSLfatal() already called */
1507         goto err;
1508     }
1509
1510     /* Generate the finished key */
1511     if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) {
1512         /* SSLfatal() already called */
1513         goto err;
1514     }
1515
1516     if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) {
1517         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1518                  ERR_R_INTERNAL_ERROR);
1519         goto err;
1520     }
1521
1522     /*
1523      * Get a hash of the ClientHello up to the start of the binders. If we are
1524      * following a HelloRetryRequest then this includes the hash of the first
1525      * ClientHello and the HelloRetryRequest itself.
1526      */
1527     if (s->hello_retry_request == SSL_HRR_PENDING) {
1528         size_t hdatalen;
1529         void *hdata;
1530
1531         hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
1532         if (hdatalen <= 0) {
1533             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1534                      SSL_R_BAD_HANDSHAKE_LENGTH);
1535             goto err;
1536         }
1537
1538         /*
1539          * For servers the handshake buffer data will include the second
1540          * ClientHello - which we don't want - so we need to take that bit off.
1541          */
1542         if (s->server) {
1543             PACKET hashprefix, msg;
1544
1545             /* Find how many bytes are left after the first two messages */
1546             if (!PACKET_buf_init(&hashprefix, hdata, hdatalen)
1547                     || !PACKET_forward(&hashprefix, 1)
1548                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
1549                     || !PACKET_forward(&hashprefix, 1)
1550                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
1551                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1552                          ERR_R_INTERNAL_ERROR);
1553                 goto err;
1554             }
1555             hdatalen -= PACKET_remaining(&hashprefix);
1556         }
1557
1558         if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) {
1559             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1560                      ERR_R_INTERNAL_ERROR);
1561             goto err;
1562         }
1563     }
1564
1565     if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
1566             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1567         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1568                  ERR_R_INTERNAL_ERROR);
1569         goto err;
1570     }
1571
1572     mackey = EVP_PKEY_new_raw_private_key(EVP_PKEY_HMAC, NULL, finishedkey,
1573                                           hashsize);
1574     if (mackey == NULL) {
1575         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1576                  ERR_R_INTERNAL_ERROR);
1577         goto err;
1578     }
1579
1580     if (!sign)
1581         binderout = tmpbinder;
1582
1583     bindersize = hashsize;
1584     if (EVP_DigestSignInit(mctx, NULL, md, NULL, mackey) <= 0
1585             || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
1586             || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
1587             || bindersize != hashsize) {
1588         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PSK_DO_BINDER,
1589                  ERR_R_INTERNAL_ERROR);
1590         goto err;
1591     }
1592
1593     if (sign) {
1594         ret = 1;
1595     } else {
1596         /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */
1597         ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0);
1598         if (!ret)
1599             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PSK_DO_BINDER,
1600                      SSL_R_BINDER_DOES_NOT_VERIFY);
1601     }
1602
1603  err:
1604     OPENSSL_cleanse(binderkey, sizeof(binderkey));
1605     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
1606     EVP_PKEY_free(mackey);
1607     EVP_MD_CTX_free(mctx);
1608
1609     return ret;
1610 }
1611
1612 static int final_early_data(SSL *s, unsigned int context, int sent)
1613 {
1614     if (!sent)
1615         return 1;
1616
1617     if (!s->server) {
1618         if (context == SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1619                 && sent
1620                 && !s->ext.early_data_ok) {
1621             /*
1622              * If we get here then the server accepted our early_data but we
1623              * later realised that it shouldn't have done (e.g. inconsistent
1624              * ALPN)
1625              */
1626             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_FINAL_EARLY_DATA,
1627                      SSL_R_BAD_EARLY_DATA);
1628             return 0;
1629         }
1630
1631         return 1;
1632     }
1633
1634     if (s->max_early_data == 0
1635             || !s->hit
1636             || s->session->ext.tick_identity != 0
1637             || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
1638             || !s->ext.early_data_ok
1639             || s->hello_retry_request != SSL_HRR_NONE
1640             || (s->ctx->allow_early_data_cb != NULL
1641                 && !s->ctx->allow_early_data_cb(s,
1642                                          s->ctx->allow_early_data_cb_data))) {
1643         s->ext.early_data = SSL_EARLY_DATA_REJECTED;
1644     } else {
1645         s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1646
1647         if (!tls13_change_cipher_state(s,
1648                     SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
1649             /* SSLfatal() already called */
1650             return 0;
1651         }
1652     }
1653
1654     return 1;
1655 }
1656
1657 static int final_maxfragmentlen(SSL *s, unsigned int context, int sent)
1658 {
1659     /*
1660      * Session resumption on server-side with MFL extension active
1661      *  BUT MFL extension packet was not resent (i.e. sent == 0)
1662      */
1663     if (s->server && s->hit && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1664             && !sent ) {
1665         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_FINAL_MAXFRAGMENTLEN,
1666                  SSL_R_BAD_EXTENSION);
1667         return 0;
1668     }
1669
1670     /* Current SSL buffer is lower than requested MFL */
1671     if (s->session && USE_MAX_FRAGMENT_LENGTH_EXT(s->session)
1672             && s->max_send_fragment < GET_MAX_FRAGMENT_LENGTH(s->session))
1673         /* trigger a larger buffer reallocation */
1674         if (!ssl3_setup_buffers(s)) {
1675             /* SSLfatal() already called */
1676             return 0;
1677         }
1678
1679     return 1;
1680 }
1681
1682 static int init_post_handshake_auth(SSL *s, unsigned int context)
1683 {
1684     s->post_handshake_auth = SSL_PHA_NONE;
1685
1686     return 1;
1687 }