b4d85d958c5f1cb430a970c14631e01dc8d4c8a6
[openssl.git] / ssl / statem / extensions.c
1 /*
2  * Copyright 2016-2017 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 "../ssl_locl.h"
12 #include "statem_locl.h"
13
14 static int final_renegotiate(SSL *s, unsigned int context, int sent,
15                                      int *al);
16 static int init_server_name(SSL *s, unsigned int context);
17 static int final_server_name(SSL *s, unsigned int context, int sent,
18                                      int *al);
19 #ifndef OPENSSL_NO_EC
20 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
21                                        int *al);
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, int *al);
32 static int init_sig_algs(SSL *s, unsigned int context);
33 static int init_certificate_authorities(SSL *s, unsigned int context);
34 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
35                                                         unsigned int context,
36                                                         X509 *x,
37                                                         size_t chainidx,
38                                                         int *al);
39 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
40                                              unsigned int context, X509 *x,
41                                              size_t chainidx, int *al);
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, int *al);
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, int *al);
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, int *al);
56 static int final_early_data(SSL *s, unsigned int context, int sent, int *al);
57
58 /* Structure to define a built-in extension */
59 typedef struct extensions_definition_st {
60     /* The defined type for the extension */
61     unsigned int type;
62     /*
63      * The context that this extension applies to, e.g. what messages and
64      * protocol versions
65      */
66     unsigned int context;
67     /*
68      * Initialise extension before parsing. Always called for relevant contexts
69      * even if extension not present
70      */
71     int (*init)(SSL *s, unsigned int context);
72     /* Parse extension sent from client to server */
73     int (*parse_ctos)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
74                       size_t chainidx, int *al);
75     /* Parse extension send from server to client */
76     int (*parse_stoc)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
77                       size_t chainidx, int *al);
78     /* Construct extension sent from server to client */
79     EXT_RETURN (*construct_stoc)(SSL *s, WPACKET *pkt, unsigned int context,
80                                  X509 *x, size_t chainidx, int *al);
81     /* Construct extension sent from client to server */
82     EXT_RETURN (*construct_ctos)(SSL *s, WPACKET *pkt, unsigned int context,
83                                  X509 *x, size_t chainidx, int *al);
84     /*
85      * Finalise extension after parsing. Always called where an extensions was
86      * initialised even if the extension was not present. |sent| is set to 1 if
87      * the extension was seen, or 0 otherwise.
88      */
89     int (*final)(SSL *s, unsigned int context, int sent, int *al);
90 } EXTENSION_DEFINITION;
91
92 /*
93  * Definitions of all built-in extensions. NOTE: Changes in the number or order
94  * of these extensions should be mirrored with equivalent changes to the
95  * indexes ( TLSEXT_IDX_* ) defined in ssl_locl.h.
96  * Each extension has an initialiser, a client and
97  * server side parser and a finaliser. The initialiser is called (if the
98  * extension is relevant to the given context) even if we did not see the
99  * extension in the message that we received. The parser functions are only
100  * called if we see the extension in the message. The finalisers are always
101  * called if the initialiser was called.
102  * There are also server and client side constructor functions which are always
103  * called during message construction if the extension is relevant for the
104  * given context.
105  * The initialisation, parsing, finalisation and construction functions are
106  * always called in the order defined in this list. Some extensions may depend
107  * on others having been processed first, so the order of this list is
108  * significant.
109  * The extension context is defined by a series of flags which specify which
110  * messages the extension is relevant to. These flags also specify whether the
111  * extension is relevant to a particular protocol or protocol version.
112  *
113  * TODO(TLS1.3): Make sure we have a test to check the consistency of these
114  */
115 #define INVALID_EXTENSION { 0x10000, 0, NULL, NULL, NULL, NULL, NULL, NULL }
116 static const EXTENSION_DEFINITION ext_defs[] = {
117     {
118         TLSEXT_TYPE_renegotiate,
119         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
120         | SSL_EXT_SSL3_ALLOWED | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
121         NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate,
122         tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate,
123         final_renegotiate
124     },
125     {
126         TLSEXT_TYPE_server_name,
127         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
128         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
129         init_server_name,
130         tls_parse_ctos_server_name, tls_parse_stoc_server_name,
131         tls_construct_stoc_server_name, tls_construct_ctos_server_name,
132         final_server_name
133     },
134 #ifndef OPENSSL_NO_SRP
135     {
136         TLSEXT_TYPE_srp,
137         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
138         init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL
139     },
140 #else
141     INVALID_EXTENSION,
142 #endif
143 #ifndef OPENSSL_NO_EC
144     {
145         TLSEXT_TYPE_ec_point_formats,
146         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
147         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
148         NULL, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats,
149         tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats,
150         final_ec_pt_formats
151     },
152     {
153         TLSEXT_TYPE_supported_groups,
154         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
155         NULL, tls_parse_ctos_supported_groups, NULL,
156         tls_construct_stoc_supported_groups,
157         tls_construct_ctos_supported_groups, NULL
158     },
159 #else
160     INVALID_EXTENSION,
161     INVALID_EXTENSION,
162 #endif
163     {
164         TLSEXT_TYPE_session_ticket,
165         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
166         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
167         init_session_ticket, tls_parse_ctos_session_ticket,
168         tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket,
169         tls_construct_ctos_session_ticket, NULL
170     },
171     {
172         TLSEXT_TYPE_signature_algorithms,
173         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST,
174         init_sig_algs, tls_parse_ctos_sig_algs,
175         tls_parse_ctos_sig_algs, tls_construct_ctos_sig_algs,
176         tls_construct_ctos_sig_algs, final_sig_algs
177     },
178 #ifndef OPENSSL_NO_OCSP
179     {
180         TLSEXT_TYPE_status_request,
181         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
182         | SSL_EXT_TLS1_3_CERTIFICATE,
183         init_status_request, tls_parse_ctos_status_request,
184         tls_parse_stoc_status_request, tls_construct_stoc_status_request,
185         tls_construct_ctos_status_request, NULL
186     },
187 #else
188     INVALID_EXTENSION,
189 #endif
190 #ifndef OPENSSL_NO_NEXTPROTONEG
191     {
192         TLSEXT_TYPE_next_proto_neg,
193         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
194         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
195         init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn,
196         tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL
197     },
198 #else
199     INVALID_EXTENSION,
200 #endif
201     {
202         /*
203          * Must appear in this list after server_name so that finalisation
204          * happens after server_name callbacks
205          */
206         TLSEXT_TYPE_application_layer_protocol_negotiation,
207         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
208         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
209         init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn,
210         tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn
211     },
212 #ifndef OPENSSL_NO_SRTP
213     {
214         TLSEXT_TYPE_use_srtp,
215         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
216         | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS | SSL_EXT_DTLS_ONLY,
217         init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp,
218         tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL
219     },
220 #else
221     INVALID_EXTENSION,
222 #endif
223     {
224         TLSEXT_TYPE_encrypt_then_mac,
225         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
226         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
227         init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm,
228         tls_construct_stoc_etm, tls_construct_ctos_etm, NULL
229     },
230 #ifndef OPENSSL_NO_CT
231     {
232         TLSEXT_TYPE_signed_certificate_timestamp,
233         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
234         | SSL_EXT_TLS1_3_CERTIFICATE,
235         NULL,
236         /*
237          * No server side support for this, but can be provided by a custom
238          * extension. This is an exception to the rule that custom extensions
239          * cannot override built in ones.
240          */
241         NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct,  NULL
242     },
243 #else
244     INVALID_EXTENSION,
245 #endif
246     {
247         TLSEXT_TYPE_extended_master_secret,
248         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO
249         | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
250         init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems,
251         tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems
252     },
253     {
254         TLSEXT_TYPE_supported_versions,
255         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY
256         | SSL_EXT_TLS1_3_ONLY,
257         NULL,
258         /* Processed inline as part of version selection */
259         NULL, NULL, NULL, tls_construct_ctos_supported_versions, NULL
260     },
261     {
262         TLSEXT_TYPE_psk_kex_modes,
263         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS_IMPLEMENTATION_ONLY
264         | SSL_EXT_TLS1_3_ONLY,
265         init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL,
266         tls_construct_ctos_psk_kex_modes, NULL
267     },
268 #ifndef OPENSSL_NO_EC
269     {
270         /*
271          * Must be in this list after supported_groups. We need that to have
272          * been parsed before we do this one.
273          */
274         TLSEXT_TYPE_key_share,
275         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
276         | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST | SSL_EXT_TLS_IMPLEMENTATION_ONLY
277         | SSL_EXT_TLS1_3_ONLY,
278         NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share,
279         tls_construct_stoc_key_share, tls_construct_ctos_key_share,
280         final_key_share
281     },
282 #endif
283     {
284         TLSEXT_TYPE_cookie,
285         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST
286         | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
287         NULL, NULL, tls_parse_stoc_cookie, NULL, tls_construct_ctos_cookie,
288         NULL
289     },
290     {
291         /*
292          * Special unsolicited ServerHello extension only used when
293          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set
294          */
295         TLSEXT_TYPE_cryptopro_bug,
296         SSL_EXT_TLS1_2_SERVER_HELLO | SSL_EXT_TLS1_2_AND_BELOW_ONLY,
297         NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
298     },
299     {
300         TLSEXT_TYPE_early_data,
301         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_ENCRYPTED_EXTENSIONS
302         | SSL_EXT_TLS1_3_NEW_SESSION_TICKET,
303         NULL, tls_parse_ctos_early_data, tls_parse_stoc_early_data,
304         tls_construct_stoc_early_data, tls_construct_ctos_early_data,
305         final_early_data
306     },
307     {
308         TLSEXT_TYPE_certificate_authorities,
309         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
310         | SSL_EXT_TLS1_3_ONLY,
311         init_certificate_authorities,
312         tls_parse_certificate_authorities, tls_parse_certificate_authorities,
313         tls_construct_certificate_authorities,
314         tls_construct_certificate_authorities, NULL,
315     },
316     {
317         /* Must be immediately before pre_shared_key */
318         TLSEXT_TYPE_padding,
319         SSL_EXT_CLIENT_HELLO,
320         NULL,
321         /* We send this, but don't read it */
322         NULL, NULL, NULL, tls_construct_ctos_padding, NULL
323     },
324     {
325         /* Required by the TLSv1.3 spec to always be the last extension */
326         TLSEXT_TYPE_psk,
327         SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_3_SERVER_HELLO
328         | SSL_EXT_TLS_IMPLEMENTATION_ONLY | SSL_EXT_TLS1_3_ONLY,
329         NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk,
330         tls_construct_ctos_psk, NULL
331     }
332 };
333
334 /* Check whether an extension's context matches the current context */
335 static int validate_context(SSL *s, unsigned int extctx, unsigned int thisctx)
336 {
337     /* Check we're allowed to use this extension in this context */
338     if ((thisctx & extctx) == 0)
339         return 0;
340
341     if (SSL_IS_DTLS(s)) {
342         if ((extctx & SSL_EXT_TLS_ONLY) != 0)
343             return 0;
344     } else if ((extctx & SSL_EXT_DTLS_ONLY) != 0) {
345         return 0;
346     }
347
348     return 1;
349 }
350
351 /*
352  * Verify whether we are allowed to use the extension |type| in the current
353  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
354  * indicate the extension is not allowed. If returning 1 then |*found| is set to
355  * the definition for the extension we found.
356  */
357 static int verify_extension(SSL *s, unsigned int context, unsigned int type,
358                             custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
359                             RAW_EXTENSION **found)
360 {
361     size_t i;
362     size_t builtin_num = OSSL_NELEM(ext_defs);
363     const EXTENSION_DEFINITION *thisext;
364
365     for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) {
366         if (type == thisext->type) {
367             if (!validate_context(s, thisext->context, context))
368                 return 0;
369
370             *found = &rawexlist[i];
371             return 1;
372         }
373     }
374
375     /* Check the custom extensions */
376     if (meths != NULL) {
377         size_t offset = 0;
378         ENDPOINT role = ENDPOINT_BOTH;
379         custom_ext_method *meth = NULL;
380
381         if ((context & SSL_EXT_CLIENT_HELLO) != 0)
382             role = ENDPOINT_SERVER;
383         else if ((context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0)
384             role = ENDPOINT_CLIENT;
385
386         meth = custom_ext_find(meths, role, type, &offset);
387         if (meth != NULL) {
388             if (!validate_context(s, meth->context, context))
389                 return 0;
390             *found = &rawexlist[offset + builtin_num];
391             return 1;
392         }
393     }
394
395     /* Unknown extension. We allow it */
396     *found = NULL;
397     return 1;
398 }
399
400 /*
401  * Check whether the context defined for an extension |extctx| means whether
402  * the extension is relevant for the current context |thisctx| or not. Returns
403  * 1 if the extension is relevant for this context, and 0 otherwise
404  */
405 int extension_is_relevant(SSL *s, unsigned int extctx, unsigned int thisctx)
406 {
407     if ((SSL_IS_DTLS(s)
408                 && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
409             || (s->version == SSL3_VERSION
410                     && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
411             || (SSL_IS_TLS13(s)
412                 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
413             || (!SSL_IS_TLS13(s) && (extctx & SSL_EXT_TLS1_3_ONLY) != 0)
414             || (s->hit && (extctx & SSL_EXT_IGNORE_ON_RESUMPTION) != 0))
415         return 0;
416
417     return 1;
418 }
419
420 /*
421  * Gather a list of all the extensions from the data in |packet]. |context|
422  * tells us which message this extension is for. The raw extension data is
423  * stored in |*res| on success. In the event of an error the alert type to use
424  * is stored in |*al|. We don't actually process the content of the extensions
425  * yet, except to check their types. This function also runs the initialiser
426  * functions for all known extensions if |init| is nonzero (whether we have
427  * collected them or not). If successful the caller is responsible for freeing
428  * the contents of |*res|.
429  *
430  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
431  * more than one extension of the same type in a ClientHello or ServerHello.
432  * This function returns 1 if all extensions are unique and we have parsed their
433  * types, and 0 if the extensions contain duplicates, could not be successfully
434  * found, or an internal error occurred. We only check duplicates for
435  * extensions that we know about. We ignore others.
436  */
437 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
438                            RAW_EXTENSION **res, int *al, size_t *len,
439                            int init)
440 {
441     PACKET extensions = *packet;
442     size_t i = 0;
443     size_t num_exts;
444     custom_ext_methods *exts = &s->cert->custext;
445     RAW_EXTENSION *raw_extensions = NULL;
446     const EXTENSION_DEFINITION *thisexd;
447
448     *res = NULL;
449
450     /*
451      * Initialise server side custom extensions. Client side is done during
452      * construction of extensions for the ClientHello.
453      */
454     if ((context & SSL_EXT_CLIENT_HELLO) != 0)
455         custom_ext_init(&s->cert->custext);
456
457     num_exts = OSSL_NELEM(ext_defs) + (exts != NULL ? exts->meths_count : 0);
458     raw_extensions = OPENSSL_zalloc(num_exts * sizeof(*raw_extensions));
459     if (raw_extensions == NULL) {
460         *al = SSL_AD_INTERNAL_ERROR;
461         SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
462         return 0;
463     }
464
465     while (PACKET_remaining(&extensions) > 0) {
466         unsigned int type, idx;
467         PACKET extension;
468         RAW_EXTENSION *thisex;
469
470         if (!PACKET_get_net_2(&extensions, &type) ||
471             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
472             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
473             *al = SSL_AD_DECODE_ERROR;
474             goto err;
475         }
476         /*
477          * Verify this extension is allowed. We only check duplicates for
478          * extensions that we recognise. We also have a special case for the
479          * PSK extension, which must be the last one in the ClientHello.
480          */
481         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
482                 || (thisex != NULL && thisex->present == 1)
483                 || (type == TLSEXT_TYPE_psk
484                     && (context & SSL_EXT_CLIENT_HELLO) != 0
485                     && PACKET_remaining(&extensions) != 0)) {
486             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
487             *al = SSL_AD_ILLEGAL_PARAMETER;
488             goto err;
489         }
490         idx = thisex - raw_extensions;
491         /*-
492          * Check that we requested this extension (if appropriate). Requests can
493          * be sent in the ClientHello and CertificateRequest. Unsolicited
494          * extensions can be sent in the NewSessionTicket. We only do this for
495          * the built-in extensions. Custom extensions have a different but
496          * similar check elsewhere.
497          * Special cases:
498          * - The HRR cookie extension is unsolicited
499          * - The renegotiate extension is unsolicited (the client signals
500          *   support via an SCSV)
501          * - The signed_certificate_timestamp extension can be provided by a
502          * custom extension or by the built-in version. We let the extension
503          * itself handle unsolicited response checks.
504          */
505         if (idx < OSSL_NELEM(ext_defs)
506                 && (context & (SSL_EXT_CLIENT_HELLO
507                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
508                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) == 0
509                 && type != TLSEXT_TYPE_cookie
510                 && type != TLSEXT_TYPE_renegotiate
511                 && type != TLSEXT_TYPE_signed_certificate_timestamp
512                 && (s->ext.extflags[idx] & SSL_EXT_FLAG_SENT) == 0) {
513             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_UNSOLICITED_EXTENSION);
514             *al = SSL_AD_UNSUPPORTED_EXTENSION;
515             goto err;
516         }
517         if (thisex != NULL) {
518             thisex->data = extension;
519             thisex->present = 1;
520             thisex->type = type;
521         }
522     }
523
524     if (init) {
525         /*
526          * Initialise all known extensions relevant to this context,
527          * whether we have found them or not
528          */
529         for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs);
530              i++, thisexd++) {
531             if (thisexd->init != NULL && (thisexd->context & context) != 0
532                 && extension_is_relevant(s, thisexd->context, context)
533                 && !thisexd->init(s, context)) {
534                 *al = SSL_AD_INTERNAL_ERROR;
535                 goto err;
536             }
537         }
538     }
539
540     *res = raw_extensions;
541     if (len != NULL)
542         *len = num_exts;
543     return 1;
544
545  err:
546     OPENSSL_free(raw_extensions);
547     return 0;
548 }
549
550 /*
551  * Runs the parser for a given extension with index |idx|. |exts| contains the
552  * list of all parsed extensions previously collected by
553  * tls_collect_extensions(). The parser is only run if it is applicable for the
554  * given |context| and the parser has not already been run. If this is for a
555  * Certificate message, then we also provide the parser with the relevant
556  * Certificate |x| and its position in the |chainidx| with 0 being the first
557  * Certificate. Returns 1 on success or 0 on failure. In the event of a failure
558  * |*al| is populated with a suitable alert code. If an extension is not present
559  * this counted as success.
560  */
561 int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
562                         RAW_EXTENSION *exts, X509 *x, size_t chainidx, int *al)
563 {
564     RAW_EXTENSION *currext = &exts[idx];
565     int (*parser)(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
566                   size_t chainidx, int *al) = NULL;
567
568     /* Skip if the extension is not present */
569     if (!currext->present)
570         return 1;
571
572     if (s->ext.debug_cb)
573         s->ext.debug_cb(s, !s->server, currext->type,
574                         PACKET_data(&currext->data),
575                         PACKET_remaining(&currext->data),
576                         s->ext.debug_arg);
577
578     /* Skip if we've already parsed this extension */
579     if (currext->parsed)
580         return 1;
581
582     currext->parsed = 1;
583
584     if (idx < OSSL_NELEM(ext_defs)) {
585         /* We are handling a built-in extension */
586         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
587
588         /* Check if extension is defined for our protocol. If not, skip */
589         if (!extension_is_relevant(s, extdef->context, context))
590             return 1;
591
592         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
593
594         if (parser != NULL)
595             return parser(s, &currext->data, context, x, chainidx, al);
596
597         /*
598          * If the parser is NULL we fall through to the custom extension
599          * processing
600          */
601     }
602
603     /* Parse custom extensions */
604     if (custom_ext_parse(s, context, currext->type,
605                          PACKET_data(&currext->data),
606                          PACKET_remaining(&currext->data),
607                          x, chainidx, al) <= 0)
608         return 0;
609
610     return 1;
611 }
612
613 /*
614  * Parse all remaining extensions that have not yet been parsed. Also calls the
615  * finalisation for all extensions at the end if |fin| is nonzero, whether we
616  * collected them or not. Returns 1 for success or 0 for failure. If we are
617  * working on a Certificate message then we also pass the Certificate |x| and
618  * its position in the |chainidx|, with 0 being the first certificate. On
619  * failure, |*al| is populated with a suitable alert code.
620  */
621 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, X509 *x,
622                              size_t chainidx, int *al, int fin)
623 {
624     size_t i, numexts = OSSL_NELEM(ext_defs);
625     const EXTENSION_DEFINITION *thisexd;
626
627     /* Calculate the number of extensions in the extensions list */
628     numexts += s->cert->custext.meths_count;
629
630     /* Parse each extension in turn */
631     for (i = 0; i < numexts; i++) {
632         if (!tls_parse_extension(s, i, context, exts, x, chainidx, al))
633             return 0;
634     }
635
636     if (fin) {
637         /*
638          * Finalise all known extensions relevant to this context,
639          * whether we have found them or not
640          */
641         for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs);
642              i++, thisexd++) {
643             if (thisexd->final != NULL && (thisexd->context & context) != 0
644                 && !thisexd->final(s, context, exts[i].present, al))
645                 return 0;
646         }
647     }
648
649     return 1;
650 }
651
652 int should_add_extension(SSL *s, unsigned int extctx, unsigned int thisctx,
653                          int max_version)
654 {
655     /* Skip if not relevant for our context */
656     if ((extctx & thisctx) == 0)
657         return 0;
658
659     /* Check if this extension is defined for our protocol. If not, skip */
660     if ((SSL_IS_DTLS(s) && (extctx & SSL_EXT_TLS_IMPLEMENTATION_ONLY) != 0)
661             || (s->version == SSL3_VERSION
662                     && (extctx & SSL_EXT_SSL3_ALLOWED) == 0)
663             || (SSL_IS_TLS13(s)
664                 && (extctx & SSL_EXT_TLS1_2_AND_BELOW_ONLY) != 0)
665             || (!SSL_IS_TLS13(s)
666                 && (extctx & SSL_EXT_TLS1_3_ONLY) != 0
667                 && (thisctx & SSL_EXT_CLIENT_HELLO) == 0)
668             || ((extctx & SSL_EXT_TLS1_3_ONLY) != 0
669                 && (thisctx & SSL_EXT_CLIENT_HELLO) != 0
670                 && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION)))
671         return 0;
672
673     return 1;
674 }
675
676 /*
677  * Construct all the extensions relevant to the current |context| and write
678  * them to |pkt|. If this is an extension for a Certificate in a Certificate
679  * message, then |x| will be set to the Certificate we are handling, and
680  * |chainidx| will indicate the position in the chainidx we are processing (with
681  * 0 being the first in the chain). Returns 1 on success or 0 on failure. If a
682  * failure occurs then |al| is populated with a suitable alert code. On a
683  * failure construction stops at the first extension to fail to construct.
684  */
685 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
686                              X509 *x, size_t chainidx, int *al)
687 {
688     size_t i;
689     int min_version, max_version = 0, reason, tmpal;
690     const EXTENSION_DEFINITION *thisexd;
691
692     /*
693      * Normally if something goes wrong during construction it's an internal
694      * error. We can always override this later.
695      */
696     tmpal = SSL_AD_INTERNAL_ERROR;
697
698     if (!WPACKET_start_sub_packet_u16(pkt)
699                /*
700                 * If extensions are of zero length then we don't even add the
701                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
702                 */
703             || ((context &
704                  (SSL_EXT_CLIENT_HELLO | SSL_EXT_TLS1_2_SERVER_HELLO)) != 0
705                 && s->version == SSL3_VERSION
706                 && !WPACKET_set_flags(pkt,
707                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
708         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
709         goto err;
710     }
711
712     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
713         reason = ssl_get_min_max_version(s, &min_version, &max_version);
714         if (reason != 0) {
715             SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, reason);
716             goto err;
717         }
718     }
719
720     /* Add custom extensions first */
721     if ((context & SSL_EXT_CLIENT_HELLO) != 0) {
722         /* On the server side with initiase during ClientHello parsing */
723         custom_ext_init(&s->cert->custext);
724     }
725     if (!custom_ext_add(s, context, pkt, x, chainidx, max_version, &tmpal)) {
726         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
727         goto err;
728     }
729
730     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
731         EXT_RETURN (*construct)(SSL *s, WPACKET *pkt, unsigned int context,
732                                 X509 *x, size_t chainidx, int *al);
733         EXT_RETURN ret;
734
735         /* Skip if not relevant for our context */
736         if (!should_add_extension(s, thisexd->context, context, max_version))
737             continue;
738
739         construct = s->server ? thisexd->construct_stoc
740                               : thisexd->construct_ctos;
741
742         if (construct == NULL)
743             continue;
744
745         ret = construct(s, pkt, context, x, chainidx, &tmpal);
746         if (ret == EXT_RETURN_FAIL)
747             goto err;
748         if (ret == EXT_RETURN_SENT
749                 && (context & (SSL_EXT_CLIENT_HELLO
750                                | SSL_EXT_TLS1_3_CERTIFICATE_REQUEST
751                                | SSL_EXT_TLS1_3_NEW_SESSION_TICKET)) != 0)
752             s->ext.extflags[i] |= SSL_EXT_FLAG_SENT;
753     }
754
755     if (!WPACKET_close(pkt)) {
756         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
757         goto err;
758     }
759
760     return 1;
761
762  err:
763     *al = tmpal;
764     return 0;
765 }
766
767 /*
768  * Built in extension finalisation and initialisation functions. All initialise
769  * or finalise the associated extension type for the given |context|. For
770  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
771  * otherwise. These functions return 1 on success or 0 on failure. In the event
772  * of a failure then |*al| is populated with a suitable error code.
773  */
774
775 static int final_renegotiate(SSL *s, unsigned int context, int sent,
776                                      int *al)
777 {
778     if (!s->server) {
779         /*
780          * Check if we can connect to a server that doesn't support safe
781          * renegotiation
782          */
783         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
784                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
785                 && !sent) {
786             *al = SSL_AD_HANDSHAKE_FAILURE;
787             SSLerr(SSL_F_FINAL_RENEGOTIATE,
788                    SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
789             return 0;
790         }
791
792         return 1;
793     }
794
795     /* Need RI if renegotiating */
796     if (s->renegotiate
797             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
798             && !sent) {
799         *al = SSL_AD_HANDSHAKE_FAILURE;
800         SSLerr(SSL_F_FINAL_RENEGOTIATE,
801                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
802         return 0;
803     }
804
805
806     return 1;
807 }
808
809 static int init_server_name(SSL *s, unsigned int context)
810 {
811     if (s->server)
812         s->servername_done = 0;
813
814     return 1;
815 }
816
817 static int final_server_name(SSL *s, unsigned int context, int sent,
818                                      int *al)
819 {
820     int ret = SSL_TLSEXT_ERR_NOACK;
821     int altmp = SSL_AD_UNRECOGNIZED_NAME;
822
823     if (s->ctx != NULL && s->ctx->ext.servername_cb != 0)
824         ret = s->ctx->ext.servername_cb(s, &altmp,
825                                         s->ctx->ext.servername_arg);
826     else if (s->session_ctx != NULL
827              && s->session_ctx->ext.servername_cb != 0)
828         ret = s->session_ctx->ext.servername_cb(s, &altmp,
829                                        s->session_ctx->ext.servername_arg);
830
831     switch (ret) {
832     case SSL_TLSEXT_ERR_ALERT_FATAL:
833         *al = altmp;
834         return 0;
835
836     case SSL_TLSEXT_ERR_ALERT_WARNING:
837         *al = altmp;
838         return 1;
839
840     case SSL_TLSEXT_ERR_NOACK:
841         s->servername_done = 0;
842         return 1;
843
844     default:
845         return 1;
846     }
847 }
848
849 #ifndef OPENSSL_NO_EC
850 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
851                                        int *al)
852 {
853     unsigned long alg_k, alg_a;
854
855     if (s->server)
856         return 1;
857
858     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
859     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
860
861     /*
862      * If we are client and using an elliptic curve cryptography cipher
863      * suite, then if server returns an EC point formats lists extension it
864      * must contain uncompressed.
865      */
866     if (s->ext.ecpointformats != NULL
867             && s->ext.ecpointformats_len > 0
868             && s->session->ext.ecpointformats != NULL
869             && s->session->ext.ecpointformats_len > 0
870             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
871         /* we are using an ECC cipher */
872         size_t i;
873         unsigned char *list = s->session->ext.ecpointformats;
874
875         for (i = 0; i < s->session->ext.ecpointformats_len; i++) {
876             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
877                 break;
878         }
879         if (i == s->session->ext.ecpointformats_len) {
880             SSLerr(SSL_F_FINAL_EC_PT_FORMATS,
881                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
882             return 0;
883         }
884     }
885
886     return 1;
887 }
888 #endif
889
890 static int init_session_ticket(SSL *s, unsigned int context)
891 {
892     if (!s->server)
893         s->ext.ticket_expected = 0;
894
895     return 1;
896 }
897
898 #ifndef OPENSSL_NO_OCSP
899 static int init_status_request(SSL *s, unsigned int context)
900 {
901     if (s->server) {
902         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
903     } else {
904         /*
905          * Ensure we get sensible values passed to tlsext_status_cb in the event
906          * that we don't receive a status message
907          */
908         OPENSSL_free(s->ext.ocsp.resp);
909         s->ext.ocsp.resp = NULL;
910         s->ext.ocsp.resp_len = 0;
911     }
912
913     return 1;
914 }
915 #endif
916
917 #ifndef OPENSSL_NO_NEXTPROTONEG
918 static int init_npn(SSL *s, unsigned int context)
919 {
920     s->s3->npn_seen = 0;
921
922     return 1;
923 }
924 #endif
925
926 static int init_alpn(SSL *s, unsigned int context)
927 {
928     OPENSSL_free(s->s3->alpn_selected);
929     s->s3->alpn_selected = NULL;
930     s->s3->alpn_selected_len = 0;
931     if (s->server) {
932         OPENSSL_free(s->s3->alpn_proposed);
933         s->s3->alpn_proposed = NULL;
934         s->s3->alpn_proposed_len = 0;
935     }
936     return 1;
937 }
938
939 static int final_alpn(SSL *s, unsigned int context, int sent, int *al)
940 {
941     const unsigned char *selected = NULL;
942     unsigned char selected_len = 0;
943
944     if (!s->server)
945         return 1;
946
947     if (s->ctx->ext.alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
948         int r = s->ctx->ext.alpn_select_cb(s, &selected, &selected_len,
949                                            s->s3->alpn_proposed,
950                                            (unsigned int)s->s3->alpn_proposed_len,
951                                            s->ctx->ext.alpn_select_cb_arg);
952
953         if (r == SSL_TLSEXT_ERR_OK) {
954             OPENSSL_free(s->s3->alpn_selected);
955             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
956             if (s->s3->alpn_selected == NULL) {
957                 *al = SSL_AD_INTERNAL_ERROR;
958                 return 0;
959             }
960             s->s3->alpn_selected_len = selected_len;
961 #ifndef OPENSSL_NO_NEXTPROTONEG
962             /* ALPN takes precedence over NPN. */
963             s->s3->npn_seen = 0;
964 #endif
965         } else if (r == SSL_TLSEXT_ERR_NOACK) {
966             /* Behave as if no callback was present. */
967             return 1;
968         } else {
969             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
970             return 0;
971         }
972     }
973
974     return 1;
975 }
976
977 static int init_sig_algs(SSL *s, unsigned int context)
978 {
979     /* Clear any signature algorithms extension received */
980     OPENSSL_free(s->s3->tmp.peer_sigalgs);
981     s->s3->tmp.peer_sigalgs = NULL;
982
983     return 1;
984 }
985
986 #ifndef OPENSSL_NO_SRP
987 static int init_srp(SSL *s, unsigned int context)
988 {
989     OPENSSL_free(s->srp_ctx.login);
990     s->srp_ctx.login = NULL;
991
992     return 1;
993 }
994 #endif
995
996 static int init_etm(SSL *s, unsigned int context)
997 {
998     s->ext.use_etm = 0;
999
1000     return 1;
1001 }
1002
1003 static int init_ems(SSL *s, unsigned int context)
1004 {
1005     if (!s->server)
1006         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1007
1008     return 1;
1009 }
1010
1011 static int final_ems(SSL *s, unsigned int context, int sent, int *al)
1012 {
1013     if (!s->server && s->hit) {
1014         /*
1015          * Check extended master secret extension is consistent with
1016          * original session.
1017          */
1018         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1019             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1020             *al = SSL_AD_HANDSHAKE_FAILURE;
1021             SSLerr(SSL_F_FINAL_EMS, SSL_R_INCONSISTENT_EXTMS);
1022             return 0;
1023         }
1024     }
1025
1026     return 1;
1027 }
1028
1029 static int init_certificate_authorities(SSL *s, unsigned int context)
1030 {
1031     sk_X509_NAME_pop_free(s->s3->tmp.peer_ca_names, X509_NAME_free);
1032     s->s3->tmp.peer_ca_names = NULL;
1033     return 1;
1034 }
1035
1036 static EXT_RETURN tls_construct_certificate_authorities(SSL *s, WPACKET *pkt,
1037                                                         unsigned int context,
1038                                                         X509 *x,
1039                                                         size_t chainidx,
1040                                                         int *al)
1041 {
1042     const STACK_OF(X509_NAME) *ca_sk = SSL_get0_CA_list(s);
1043
1044     if (ca_sk == NULL || sk_X509_NAME_num(ca_sk) == 0)
1045         return EXT_RETURN_NOT_SENT;
1046
1047     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_certificate_authorities)
1048         || !WPACKET_start_sub_packet_u16(pkt)
1049         || !construct_ca_names(s, pkt)
1050         || !WPACKET_close(pkt)) {
1051         SSLerr(SSL_F_TLS_CONSTRUCT_CERTIFICATE_AUTHORITIES,
1052                ERR_R_INTERNAL_ERROR);
1053         return EXT_RETURN_FAIL;
1054     }
1055
1056     return EXT_RETURN_SENT;
1057 }
1058
1059 static int tls_parse_certificate_authorities(SSL *s, PACKET *pkt,
1060                                              unsigned int context, X509 *x,
1061                                              size_t chainidx, int *al)
1062 {
1063     if (!parse_ca_names(s, pkt, al))
1064         return 0;
1065     if (PACKET_remaining(pkt) != 0) {
1066         *al = SSL_AD_DECODE_ERROR;
1067         return 0;
1068     }
1069     return 1;
1070 }
1071
1072 #ifndef OPENSSL_NO_SRTP
1073 static int init_srtp(SSL *s, unsigned int context)
1074 {
1075     if (s->server)
1076         s->srtp_profile = NULL;
1077
1078     return 1;
1079 }
1080 #endif
1081
1082 static int final_sig_algs(SSL *s, unsigned int context, int sent, int *al)
1083 {
1084     if (!sent && SSL_IS_TLS13(s) && !s->hit) {
1085         *al = TLS13_AD_MISSING_EXTENSION;
1086         SSLerr(SSL_F_FINAL_SIG_ALGS, SSL_R_MISSING_SIGALGS_EXTENSION);
1087         return 0;
1088     }
1089
1090     return 1;
1091 }
1092
1093 #ifndef OPENSSL_NO_EC
1094 static int final_key_share(SSL *s, unsigned int context, int sent, int *al)
1095 {
1096     if (!SSL_IS_TLS13(s))
1097         return 1;
1098
1099     /* Nothing to do for key_share in an HRR */
1100     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0)
1101         return 1;
1102
1103     /*
1104      * If
1105      *     we are a client
1106      *     AND
1107      *     we have no key_share
1108      *     AND
1109      *     (we are not resuming
1110      *      OR the kex_mode doesn't allow non key_share resumes)
1111      * THEN
1112      *     fail;
1113      */
1114     if (!s->server
1115             && !sent
1116             && (!s->hit
1117                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) {
1118         /* Nothing left we can do - just fail */
1119         *al = SSL_AD_MISSING_EXTENSION;
1120         SSLerr(SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
1121         return 0;
1122     }
1123     /*
1124      * If
1125      *     we are a server
1126      *     AND
1127      *     we have no key_share
1128      * THEN
1129      *     If
1130      *         we didn't already send a HelloRetryRequest
1131      *         AND
1132      *         the client sent a key_share extension
1133      *         AND
1134      *         (we are not resuming
1135      *          OR the kex_mode allows key_share resumes)
1136      *         AND
1137      *         a shared group exists
1138      *     THEN
1139      *         send a HelloRetryRequest
1140      *     ELSE If
1141      *         we are not resuming
1142      *         OR
1143      *         the kex_mode doesn't allow non key_share resumes
1144      *     THEN
1145      *         fail;
1146      */
1147     if (s->server && s->s3->peer_tmp == NULL) {
1148         /* No suitable share */
1149         if (s->hello_retry_request == 0 && sent
1150                 && (!s->hit
1151                     || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE)
1152                        != 0)) {
1153             const unsigned char *pcurves, *pcurvestmp, *clntcurves;
1154             size_t num_curves, clnt_num_curves, i;
1155             unsigned int group_id = 0;
1156
1157             /* Check if a shared group exists */
1158
1159             /* Get the clients list of supported groups. */
1160             if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
1161                 *al = SSL_AD_INTERNAL_ERROR;
1162                 SSLerr(SSL_F_FINAL_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1163                 return 0;
1164             }
1165
1166             /* Get our list of available groups */
1167             if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
1168                 *al = SSL_AD_INTERNAL_ERROR;
1169                 SSLerr(SSL_F_FINAL_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1170                 return 0;
1171             }
1172
1173             /* Find the first group we allow that is also in client's list */
1174             for (i = 0, pcurvestmp = pcurves; i < num_curves;
1175                  i++, pcurvestmp += 2) {
1176                 group_id = bytestogroup(pcurvestmp);
1177
1178                 if (check_in_list(s, group_id, clntcurves, clnt_num_curves, 1))
1179                     break;
1180             }
1181
1182             if (i < num_curves) {
1183                 /* A shared group exists so send a HelloRetryRequest */
1184                 s->s3->group_id = group_id;
1185                 s->hello_retry_request = 1;
1186                 return 1;
1187             }
1188         }
1189         if (!s->hit
1190                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0) {
1191             /* Nothing left we can do - just fail */
1192             if (!sent)
1193                 *al = SSL_AD_MISSING_EXTENSION;
1194             else
1195                 *al = SSL_AD_HANDSHAKE_FAILURE;
1196             SSLerr(SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
1197             return 0;
1198         }
1199     }
1200
1201     /* We have a key_share so don't send any more HelloRetryRequest messages */
1202     if (s->server)
1203         s->hello_retry_request = 0;
1204
1205     /*
1206      * For a client side resumption with no key_share we need to generate
1207      * the handshake secret (otherwise this is done during key_share
1208      * processing).
1209      */
1210     if (!sent && !s->server && !tls13_generate_handshake_secret(s, NULL, 0)) {
1211         *al = SSL_AD_INTERNAL_ERROR;
1212         SSLerr(SSL_F_FINAL_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1213         return 0;
1214     }
1215
1216     return 1;
1217 }
1218 #endif
1219
1220 static int init_psk_kex_modes(SSL *s, unsigned int context)
1221 {
1222     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
1223     return 1;
1224 }
1225
1226 int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
1227                       size_t binderoffset, const unsigned char *binderin,
1228                       unsigned char *binderout,
1229                       SSL_SESSION *sess, int sign)
1230 {
1231     EVP_PKEY *mackey = NULL;
1232     EVP_MD_CTX *mctx = NULL;
1233     unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE];
1234     unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE];
1235     const char resumption_label[] = "res binder";
1236     size_t bindersize, hashsize = EVP_MD_size(md);
1237     int ret = -1;
1238
1239     /* Generate the early_secret */
1240     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
1241                                sess->master_key_length,
1242                                (unsigned char *)&s->early_secret)) {
1243         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1244         goto err;
1245     }
1246
1247     /*
1248      * Create the handshake hash for the binder key...the messages so far are
1249      * empty!
1250      */
1251     mctx = EVP_MD_CTX_new();
1252     if (mctx == NULL
1253             || EVP_DigestInit_ex(mctx, md, NULL) <= 0
1254             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1255         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1256         goto err;
1257     }
1258
1259     /* Generate the binder key */
1260     if (!tls13_hkdf_expand(s, md, s->early_secret,
1261                            (unsigned char *)resumption_label,
1262                            sizeof(resumption_label) - 1, hash, binderkey,
1263                            hashsize)) {
1264         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1265         goto err;
1266     }
1267
1268     /* Generate the finished key */
1269     if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) {
1270         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1271         goto err;
1272     }
1273
1274     if (EVP_DigestInit_ex(mctx, md, NULL) <= 0) {
1275         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1276         goto err;
1277     }
1278
1279     /*
1280      * Get a hash of the ClientHello up to the start of the binders. If we are
1281      * following a HelloRetryRequest then this includes the hash of the first
1282      * ClientHello and the HelloRetryRequest itself.
1283      */
1284     if (s->hello_retry_request) {
1285         size_t hdatalen;
1286         void *hdata;
1287
1288         hdatalen = BIO_get_mem_data(s->s3->handshake_buffer, &hdata);
1289         if (hdatalen <= 0) {
1290             SSLerr(SSL_F_TLS_PSK_DO_BINDER, SSL_R_BAD_HANDSHAKE_LENGTH);
1291             goto err;
1292         }
1293
1294         /*
1295          * For servers the handshake buffer data will include the second
1296          * ClientHello - which we don't want - so we need to take that bit off.
1297          */
1298         if (s->server) {
1299             PACKET hashprefix, msg;
1300
1301             /* Find how many bytes are left after the first two messages */
1302             if (!PACKET_buf_init(&hashprefix, hdata, hdatalen)
1303                     || !PACKET_forward(&hashprefix, 1)
1304                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)
1305                     || !PACKET_forward(&hashprefix, 1)
1306                     || !PACKET_get_length_prefixed_3(&hashprefix, &msg)) {
1307                 SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1308                 goto err;
1309             }
1310             hdatalen -= PACKET_remaining(&hashprefix);
1311         }
1312
1313         if (EVP_DigestUpdate(mctx, hdata, hdatalen) <= 0) {
1314             SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1315             goto err;
1316         }
1317     }
1318
1319     if (EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
1320             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1321         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1322         goto err;
1323     }
1324
1325     mackey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, finishedkey, hashsize);
1326     if (mackey == NULL) {
1327         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1328         goto err;
1329     }
1330
1331     if (!sign)
1332         binderout = tmpbinder;
1333
1334     bindersize = hashsize;
1335     if (EVP_DigestSignInit(mctx, NULL, md, NULL, mackey) <= 0
1336             || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
1337             || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
1338             || bindersize != hashsize) {
1339         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1340         goto err;
1341     }
1342
1343     if (sign) {
1344         ret = 1;
1345     } else {
1346         /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */
1347         ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0);
1348     }
1349
1350  err:
1351     OPENSSL_cleanse(binderkey, sizeof(binderkey));
1352     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
1353     EVP_PKEY_free(mackey);
1354     EVP_MD_CTX_free(mctx);
1355
1356     return ret;
1357 }
1358
1359 static int final_early_data(SSL *s, unsigned int context, int sent, int *al)
1360 {
1361     if (!s->server || !sent)
1362         return 1;
1363
1364     if (s->max_early_data == 0
1365             || !s->hit
1366             || s->session->ext.tick_identity != 0
1367             || s->early_data_state != SSL_EARLY_DATA_ACCEPTING
1368             || !s->ext.early_data_ok
1369             || s->hello_retry_request
1370             || s->s3->alpn_selected_len != s->session->ext.alpn_selected_len
1371             || (s->s3->alpn_selected_len > 0
1372                 && memcmp(s->s3->alpn_selected, s->session->ext.alpn_selected,
1373                           s->s3->alpn_selected_len) != 0)) {
1374         s->ext.early_data = SSL_EARLY_DATA_REJECTED;
1375     } else {
1376         s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1377
1378         if (!tls13_change_cipher_state(s,
1379                     SSL3_CC_EARLY | SSL3_CHANGE_CIPHER_SERVER_READ)) {
1380             *al = SSL_AD_INTERNAL_ERROR;
1381             return 0;
1382         }
1383     }
1384
1385     return 1;
1386 }