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