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