Updates following review of SSL_stateless() code
[openssl.git] / ssl / statem / extensions_srvr.c
1 /*
2  * Copyright 2016-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <openssl/ocsp.h>
11 #include "../ssl_locl.h"
12 #include "statem_locl.h"
13 #include "internal/cryptlib.h"
14
15 #define COOKIE_STATE_FORMAT_VERSION     0
16
17 /*
18  * 2 bytes for packet length, 2 bytes for format version, 2 bytes for
19  * protocol version, 2 bytes for group id, 2 bytes for cipher id, 1 byte for
20  * key_share present flag, 4 bytes for timestamp, 2 bytes for the hashlen,
21  * EVP_MAX_MD_SIZE for transcript hash, 1 byte for app cookie length, app cookie
22  * length bytes, SHA256_DIGEST_LENGTH bytes for the HMAC of the whole thing.
23  */
24 #define MAX_COOKIE_SIZE (2 + 2 + 2 + 2 + 2 + 1 + 4 + 2 + EVP_MAX_MD_SIZE + 1 \
25                          + SSL_COOKIE_LENGTH + SHA256_DIGEST_LENGTH)
26
27 /*
28  * Message header + 2 bytes for protocol version + number of random bytes +
29  * + 1 byte for legacy session id length + number of bytes in legacy session id
30  * + 2 bytes for ciphersuite + 1 byte for legacy compression
31  * + 2 bytes for extension block length + 6 bytes for key_share extension
32  * + 4 bytes for cookie extension header + the number of bytes in the cookie
33  */
34 #define MAX_HRR_SIZE    (SSL3_HM_HEADER_LENGTH + 2 + SSL3_RANDOM_SIZE + 1 \
35                          + SSL_MAX_SSL_SESSION_ID_LENGTH + 2 + 1 + 2 + 6 + 4 \
36                          + MAX_COOKIE_SIZE)
37
38 /*
39  * Parse the client's renegotiation binding and abort if it's not right
40  */
41 int tls_parse_ctos_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
42                                X509 *x, size_t chainidx)
43 {
44     unsigned int ilen;
45     const unsigned char *data;
46
47     /* Parse the length byte */
48     if (!PACKET_get_1(pkt, &ilen)
49         || !PACKET_get_bytes(pkt, &data, ilen)) {
50         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
51                  SSL_R_RENEGOTIATION_ENCODING_ERR);
52         return 0;
53     }
54
55     /* Check that the extension matches */
56     if (ilen != s->s3->previous_client_finished_len) {
57         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
58                  SSL_R_RENEGOTIATION_MISMATCH);
59         return 0;
60     }
61
62     if (memcmp(data, s->s3->previous_client_finished,
63                s->s3->previous_client_finished_len)) {
64         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
65                  SSL_R_RENEGOTIATION_MISMATCH);
66         return 0;
67     }
68
69     s->s3->send_connection_binding = 1;
70
71     return 1;
72 }
73
74 /*-
75  * The servername extension is treated as follows:
76  *
77  * - Only the hostname type is supported with a maximum length of 255.
78  * - The servername is rejected if too long or if it contains zeros,
79  *   in which case an fatal alert is generated.
80  * - The servername field is maintained together with the session cache.
81  * - When a session is resumed, the servername call back invoked in order
82  *   to allow the application to position itself to the right context.
83  * - The servername is acknowledged if it is new for a session or when
84  *   it is identical to a previously used for the same session.
85  *   Applications can control the behaviour.  They can at any time
86  *   set a 'desirable' servername for a new SSL object. This can be the
87  *   case for example with HTTPS when a Host: header field is received and
88  *   a renegotiation is requested. In this case, a possible servername
89  *   presented in the new client hello is only acknowledged if it matches
90  *   the value of the Host: field.
91  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
92  *   if they provide for changing an explicit servername context for the
93  *   session, i.e. when the session has been established with a servername
94  *   extension.
95  * - On session reconnect, the servername extension may be absent.
96  */
97 int tls_parse_ctos_server_name(SSL *s, PACKET *pkt, unsigned int context,
98                                X509 *x, size_t chainidx)
99 {
100     unsigned int servname_type;
101     PACKET sni, hostname;
102
103     if (!PACKET_as_length_prefixed_2(pkt, &sni)
104         /* ServerNameList must be at least 1 byte long. */
105         || PACKET_remaining(&sni) == 0) {
106         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
107                  SSL_R_BAD_EXTENSION);
108         return 0;
109     }
110
111     /*
112      * Although the intent was for server_name to be extensible, RFC 4366
113      * was not clear about it; and so OpenSSL among other implementations,
114      * always and only allows a 'host_name' name types.
115      * RFC 6066 corrected the mistake but adding new name types
116      * is nevertheless no longer feasible, so act as if no other
117      * SNI types can exist, to simplify parsing.
118      *
119      * Also note that the RFC permits only one SNI value per type,
120      * i.e., we can only have a single hostname.
121      */
122     if (!PACKET_get_1(&sni, &servname_type)
123         || servname_type != TLSEXT_NAMETYPE_host_name
124         || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
125         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
126                  SSL_R_BAD_EXTENSION);
127         return 0;
128     }
129
130     if (!s->hit) {
131         if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
132             SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME,
133                      SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
134                      SSL_R_BAD_EXTENSION);
135             return 0;
136         }
137
138         if (PACKET_contains_zero_byte(&hostname)) {
139             SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME,
140                      SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
141                      SSL_R_BAD_EXTENSION);
142             return 0;
143         }
144
145         OPENSSL_free(s->session->ext.hostname);
146         s->session->ext.hostname = NULL;
147         if (!PACKET_strndup(&hostname, &s->session->ext.hostname)) {
148             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
149                      ERR_R_INTERNAL_ERROR);
150             return 0;
151         }
152
153         s->servername_done = 1;
154     } else {
155         /*
156          * TODO(openssl-team): if the SNI doesn't match, we MUST
157          * fall back to a full handshake.
158          */
159         s->servername_done = s->session->ext.hostname
160             && PACKET_equal(&hostname, s->session->ext.hostname,
161                             strlen(s->session->ext.hostname));
162
163         if (!s->servername_done && s->session->ext.hostname != NULL)
164             s->ext.early_data_ok = 0;
165     }
166
167     return 1;
168 }
169
170 int tls_parse_ctos_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
171                                   X509 *x, size_t chainidx)
172 {
173     unsigned int value;
174
175     if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) {
176         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
177                  SSL_R_BAD_EXTENSION);
178         return 0;
179     }
180
181     /* Received |value| should be a valid max-fragment-length code. */
182     if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) {
183         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
184                  SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
185                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
186         return 0;
187     }
188
189     /*
190      * RFC 6066:  The negotiated length applies for the duration of the session
191      * including session resumptions.
192      * We should receive the same code as in resumed session !
193      */
194     if (s->hit && s->session->ext.max_fragment_len_mode != value) {
195         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
196                  SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
197                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
198         return 0;
199     }
200
201     /*
202      * Store it in session, so it'll become binding for us
203      * and we'll include it in a next Server Hello.
204      */
205     s->session->ext.max_fragment_len_mode = value;
206     return 1;
207 }
208
209 #ifndef OPENSSL_NO_SRP
210 int tls_parse_ctos_srp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
211                        size_t chainidx)
212 {
213     PACKET srp_I;
214
215     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
216             || PACKET_contains_zero_byte(&srp_I)) {
217         SSLfatal(s, SSL_AD_DECODE_ERROR,
218                  SSL_F_TLS_PARSE_CTOS_SRP,
219                  SSL_R_BAD_EXTENSION);
220         return 0;
221     }
222
223     /*
224      * TODO(openssl-team): currently, we re-authenticate the user
225      * upon resumption. Instead, we MUST ignore the login.
226      */
227     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
228         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_SRP,
229                  ERR_R_INTERNAL_ERROR);
230         return 0;
231     }
232
233     return 1;
234 }
235 #endif
236
237 #ifndef OPENSSL_NO_EC
238 int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
239                                  X509 *x, size_t chainidx)
240 {
241     PACKET ec_point_format_list;
242
243     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
244         || PACKET_remaining(&ec_point_format_list) == 0) {
245         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS,
246                  SSL_R_BAD_EXTENSION);
247         return 0;
248     }
249
250     if (!s->hit) {
251         if (!PACKET_memdup(&ec_point_format_list,
252                            &s->session->ext.ecpointformats,
253                            &s->session->ext.ecpointformats_len)) {
254             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
255                      SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
256             return 0;
257         }
258     }
259
260     return 1;
261 }
262 #endif                          /* OPENSSL_NO_EC */
263
264 int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
265                                   X509 *x, size_t chainidx)
266 {
267     if (s->ext.session_ticket_cb &&
268             !s->ext.session_ticket_cb(s, PACKET_data(pkt),
269                                   PACKET_remaining(pkt),
270                                   s->ext.session_ticket_cb_arg)) {
271         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
272                  SSL_F_TLS_PARSE_CTOS_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
273         return 0;
274     }
275
276     return 1;
277 }
278
279 int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
280                             size_t chainidx)
281 {
282     PACKET supported_sig_algs;
283
284     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
285             || PACKET_remaining(&supported_sig_algs) == 0) {
286         SSLfatal(s, SSL_AD_DECODE_ERROR,
287                  SSL_F_TLS_PARSE_CTOS_SIG_ALGS, SSL_R_BAD_EXTENSION);
288         return 0;
289     }
290
291     if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs)) {
292         SSLfatal(s, SSL_AD_DECODE_ERROR,
293                  SSL_F_TLS_PARSE_CTOS_SIG_ALGS, SSL_R_BAD_EXTENSION);
294         return 0;
295     }
296
297     return 1;
298 }
299
300 #ifndef OPENSSL_NO_OCSP
301 int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, unsigned int context,
302                                   X509 *x, size_t chainidx)
303 {
304     PACKET responder_id_list, exts;
305
306     /* Not defined if we get one of these in a client Certificate */
307     if (x != NULL)
308         return 1;
309
310     if (!PACKET_get_1(pkt, (unsigned int *)&s->ext.status_type)) {
311         SSLfatal(s, SSL_AD_DECODE_ERROR,
312                  SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
313         return 0;
314     }
315
316     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
317         /*
318          * We don't know what to do with any other type so ignore it.
319          */
320         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
321         return 1;
322     }
323
324     if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
325         SSLfatal(s, SSL_AD_DECODE_ERROR,
326                  SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
327         return 0;
328     }
329
330     /*
331      * We remove any OCSP_RESPIDs from a previous handshake
332      * to prevent unbounded memory growth - CVE-2016-6304
333      */
334     sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
335     if (PACKET_remaining(&responder_id_list) > 0) {
336         s->ext.ocsp.ids = sk_OCSP_RESPID_new_null();
337         if (s->ext.ocsp.ids == NULL) {
338             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
339                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, ERR_R_MALLOC_FAILURE);
340             return 0;
341         }
342     } else {
343         s->ext.ocsp.ids = NULL;
344     }
345
346     while (PACKET_remaining(&responder_id_list) > 0) {
347         OCSP_RESPID *id;
348         PACKET responder_id;
349         const unsigned char *id_data;
350
351         if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id)
352                 || PACKET_remaining(&responder_id) == 0) {
353             SSLfatal(s, SSL_AD_DECODE_ERROR,
354                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
355             return 0;
356         }
357
358         id_data = PACKET_data(&responder_id);
359         /* TODO(size_t): Convert d2i_* to size_t */
360         id = d2i_OCSP_RESPID(NULL, &id_data,
361                              (int)PACKET_remaining(&responder_id));
362         if (id == NULL) {
363             SSLfatal(s, SSL_AD_DECODE_ERROR,
364                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
365             return 0;
366         }
367
368         if (id_data != PACKET_end(&responder_id)) {
369             OCSP_RESPID_free(id);
370             SSLfatal(s, SSL_AD_DECODE_ERROR,
371                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
372
373             return 0;
374         }
375
376         if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) {
377             OCSP_RESPID_free(id);
378             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
379                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
380
381             return 0;
382         }
383     }
384
385     /* Read in request_extensions */
386     if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
387         SSLfatal(s, SSL_AD_DECODE_ERROR,
388                  SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
389         return 0;
390     }
391
392     if (PACKET_remaining(&exts) > 0) {
393         const unsigned char *ext_data = PACKET_data(&exts);
394
395         sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts,
396                                    X509_EXTENSION_free);
397         s->ext.ocsp.exts =
398             d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
399         if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) {
400             SSLfatal(s, SSL_AD_DECODE_ERROR,
401                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
402             return 0;
403         }
404     }
405
406     return 1;
407 }
408 #endif
409
410 #ifndef OPENSSL_NO_NEXTPROTONEG
411 int tls_parse_ctos_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
412                        size_t chainidx)
413 {
414     /*
415      * We shouldn't accept this extension on a
416      * renegotiation.
417      */
418     if (SSL_IS_FIRST_HANDSHAKE(s))
419         s->s3->npn_seen = 1;
420
421     return 1;
422 }
423 #endif
424
425 /*
426  * Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN
427  * extension, not including type and length. Returns: 1 on success, 0 on error.
428  */
429 int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
430                         size_t chainidx)
431 {
432     PACKET protocol_list, save_protocol_list, protocol;
433
434     if (!SSL_IS_FIRST_HANDSHAKE(s))
435         return 1;
436
437     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
438         || PACKET_remaining(&protocol_list) < 2) {
439         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
440                  SSL_R_BAD_EXTENSION);
441         return 0;
442     }
443
444     save_protocol_list = protocol_list;
445     do {
446         /* Protocol names can't be empty. */
447         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
448                 || PACKET_remaining(&protocol) == 0) {
449             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
450                      SSL_R_BAD_EXTENSION);
451             return 0;
452         }
453     } while (PACKET_remaining(&protocol_list) != 0);
454
455     OPENSSL_free(s->s3->alpn_proposed);
456     s->s3->alpn_proposed = NULL;
457     s->s3->alpn_proposed_len = 0;
458     if (!PACKET_memdup(&save_protocol_list,
459                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
460         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
461                  ERR_R_INTERNAL_ERROR);
462         return 0;
463     }
464
465     return 1;
466 }
467
468 #ifndef OPENSSL_NO_SRTP
469 int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
470                             size_t chainidx)
471 {
472     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
473     unsigned int ct, mki_len, id;
474     int i, srtp_pref;
475     PACKET subpkt;
476
477     /* Ignore this if we have no SRTP profiles */
478     if (SSL_get_srtp_profiles(s) == NULL)
479         return 1;
480
481     /* Pull off the length of the cipher suite list  and check it is even */
482     if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0
483             || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
484         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
485                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
486         return 0;
487     }
488
489     srvr = SSL_get_srtp_profiles(s);
490     s->srtp_profile = NULL;
491     /* Search all profiles for a match initially */
492     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
493
494     while (PACKET_remaining(&subpkt)) {
495         if (!PACKET_get_net_2(&subpkt, &id)) {
496             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
497                      SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
498             return 0;
499         }
500
501         /*
502          * Only look for match in profiles of higher preference than
503          * current match.
504          * If no profiles have been have been configured then this
505          * does nothing.
506          */
507         for (i = 0; i < srtp_pref; i++) {
508             SRTP_PROTECTION_PROFILE *sprof =
509                 sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
510
511             if (sprof->id == id) {
512                 s->srtp_profile = sprof;
513                 srtp_pref = i;
514                 break;
515             }
516         }
517     }
518
519     /* Now extract the MKI value as a sanity check, but discard it for now */
520     if (!PACKET_get_1(pkt, &mki_len)) {
521         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
522                  SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
523         return 0;
524     }
525
526     if (!PACKET_forward(pkt, mki_len)
527         || PACKET_remaining(pkt)) {
528         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
529                  SSL_R_BAD_SRTP_MKI_VALUE);
530         return 0;
531     }
532
533     return 1;
534 }
535 #endif
536
537 int tls_parse_ctos_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
538                        size_t chainidx)
539 {
540     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
541         s->ext.use_etm = 1;
542
543     return 1;
544 }
545
546 /*
547  * Process a psk_kex_modes extension received in the ClientHello. |pkt| contains
548  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
549  */
550 int tls_parse_ctos_psk_kex_modes(SSL *s, PACKET *pkt, unsigned int context,
551                                  X509 *x, size_t chainidx)
552 {
553 #ifndef OPENSSL_NO_TLS1_3
554     PACKET psk_kex_modes;
555     unsigned int mode;
556
557     if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes)
558             || PACKET_remaining(&psk_kex_modes) == 0) {
559         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES,
560                  SSL_R_BAD_EXTENSION);
561         return 0;
562     }
563
564     while (PACKET_get_1(&psk_kex_modes, &mode)) {
565         if (mode == TLSEXT_KEX_MODE_KE_DHE)
566             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE_DHE;
567         else if (mode == TLSEXT_KEX_MODE_KE
568                 && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0)
569             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
570     }
571 #endif
572
573     return 1;
574 }
575
576 /*
577  * Process a key_share extension received in the ClientHello. |pkt| contains
578  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
579  */
580 int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
581                              size_t chainidx)
582 {
583 #ifndef OPENSSL_NO_TLS1_3
584     unsigned int group_id;
585     PACKET key_share_list, encoded_pt;
586     const uint16_t *clntgroups, *srvrgroups;
587     size_t clnt_num_groups, srvr_num_groups;
588     int found = 0;
589
590     if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0)
591         return 1;
592
593     /* Sanity check */
594     if (s->s3->peer_tmp != NULL) {
595         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
596                  ERR_R_INTERNAL_ERROR);
597         return 0;
598     }
599
600     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
601         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
602                  SSL_R_LENGTH_MISMATCH);
603         return 0;
604     }
605
606     /* Get our list of supported groups */
607     tls1_get_supported_groups(s, &srvrgroups, &srvr_num_groups);
608     /* Get the clients list of supported groups. */
609     tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups);
610     if (clnt_num_groups == 0) {
611         /*
612          * This can only happen if the supported_groups extension was not sent,
613          * because we verify that the length is non-zero when we process that
614          * extension.
615          */
616         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
617                  SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION);
618         return 0;
619     }
620
621     if (s->s3->group_id != 0 && PACKET_remaining(&key_share_list) == 0) {
622         /*
623          * If we set a group_id already, then we must have sent an HRR
624          * requesting a new key_share. If we haven't got one then that is an
625          * error
626          */
627         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
628                  SSL_R_BAD_KEY_SHARE);
629         return 0;
630     }
631
632     while (PACKET_remaining(&key_share_list) > 0) {
633         if (!PACKET_get_net_2(&key_share_list, &group_id)
634                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
635                 || PACKET_remaining(&encoded_pt) == 0) {
636             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
637                      SSL_R_LENGTH_MISMATCH);
638             return 0;
639         }
640
641         /*
642          * If we already found a suitable key_share we loop through the
643          * rest to verify the structure, but don't process them.
644          */
645         if (found)
646             continue;
647
648         /*
649          * If we sent an HRR then the key_share sent back MUST be for the group
650          * we requested, and must be the only key_share sent.
651          */
652         if (s->s3->group_id != 0
653                 && (group_id != s->s3->group_id
654                     || PACKET_remaining(&key_share_list) != 0)) {
655             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
656                      SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
657             return 0;
658         }
659
660         /* Check if this share is in supported_groups sent from client */
661         if (!check_in_list(s, group_id, clntgroups, clnt_num_groups, 0)) {
662             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
663                      SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
664             return 0;
665         }
666
667         /* Check if this share is for a group we can use */
668         if (!check_in_list(s, group_id, srvrgroups, srvr_num_groups, 1)) {
669             /* Share not suitable */
670             continue;
671         }
672
673         if ((s->s3->peer_tmp = ssl_generate_param_group(group_id)) == NULL) {
674             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
675                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
676             return 0;
677         }
678
679         s->s3->group_id = group_id;
680
681         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
682                 PACKET_data(&encoded_pt),
683                 PACKET_remaining(&encoded_pt))) {
684             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
685                      SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_ECPOINT);
686             return 0;
687         }
688
689         found = 1;
690     }
691 #endif
692
693     return 1;
694 }
695
696 int tls_parse_ctos_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
697                           size_t chainidx)
698 {
699     unsigned int format, version, key_share, group_id;
700     EVP_MD_CTX *hctx;
701     EVP_PKEY *pkey;
702     PACKET cookie, raw, chhash, appcookie;
703     WPACKET hrrpkt;
704     const unsigned char *data, *mdin, *ciphdata;
705     unsigned char hmac[SHA256_DIGEST_LENGTH];
706     unsigned char hrr[MAX_HRR_SIZE];
707     size_t rawlen, hmaclen, hrrlen, ciphlen;
708     unsigned long tm, now;
709
710     /* Ignore any cookie if we're not set up to verify it */
711     if (s->ctx->app_verify_cookie_cb == NULL
712             || (s->s3->flags & TLS1_FLAGS_STATELESS) == 0)
713         return 1;
714
715     if (!PACKET_as_length_prefixed_2(pkt, &cookie)) {
716         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
717                  SSL_R_LENGTH_MISMATCH);
718         return 0;
719     }
720
721     raw = cookie;
722     data = PACKET_data(&raw);
723     rawlen = PACKET_remaining(&raw);
724     if (rawlen < SHA256_DIGEST_LENGTH
725             || !PACKET_forward(&raw, rawlen - SHA256_DIGEST_LENGTH)) {
726         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
727                  SSL_R_LENGTH_MISMATCH);
728         return 0;
729     }
730     mdin = PACKET_data(&raw);
731
732     /* Verify the HMAC of the cookie */
733     hctx = EVP_MD_CTX_create();
734     pkey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
735                                 s->session_ctx->ext.cookie_hmac_key,
736                                 sizeof(s->session_ctx->ext.cookie_hmac_key));
737     if (hctx == NULL || pkey == NULL) {
738         EVP_MD_CTX_free(hctx);
739         EVP_PKEY_free(pkey);
740         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
741                  ERR_R_MALLOC_FAILURE);
742         return 0;
743     }
744
745     hmaclen = SHA256_DIGEST_LENGTH;
746     if (EVP_DigestSignInit(hctx, NULL, EVP_sha256(), NULL, pkey) <= 0
747             || EVP_DigestSign(hctx, hmac, &hmaclen, data,
748                               rawlen - SHA256_DIGEST_LENGTH) <= 0
749             || hmaclen != SHA256_DIGEST_LENGTH) {
750         EVP_MD_CTX_free(hctx);
751         EVP_PKEY_free(pkey);
752         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
753                  ERR_R_INTERNAL_ERROR);
754         return 0;
755     }
756
757     EVP_MD_CTX_free(hctx);
758     EVP_PKEY_free(pkey);
759
760     if (CRYPTO_memcmp(hmac, mdin, SHA256_DIGEST_LENGTH) != 0) {
761         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_CTOS_COOKIE,
762                  SSL_R_COOKIE_MISMATCH);
763         return 0;
764     }
765
766     if (!PACKET_get_net_2(&cookie, &format)) {
767         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
768                  SSL_R_LENGTH_MISMATCH);
769         return 0;
770     }
771     /* Check the cookie format is something we recognise. Ignore it if not */
772     if (format != COOKIE_STATE_FORMAT_VERSION)
773         return 1;
774
775     /*
776      * The rest of these checks really shouldn't fail since we have verified the
777      * HMAC above.
778      */
779
780     /* Check the version number is sane */
781     if (!PACKET_get_net_2(&cookie, &version)) {
782         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
783                  SSL_R_LENGTH_MISMATCH);
784         return 0;
785     }
786     if (version != TLS1_3_VERSION) {
787         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_CTOS_COOKIE,
788                  SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
789         return 0;
790     }
791
792     if (!PACKET_get_net_2(&cookie, &group_id)) {
793         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
794                  SSL_R_LENGTH_MISMATCH);
795         return 0;
796     }
797
798     ciphdata = PACKET_data(&cookie);
799     if (!PACKET_forward(&cookie, 2)) {
800         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
801                  SSL_R_LENGTH_MISMATCH);
802         return 0;
803     }
804     if (group_id != s->s3->group_id
805             || s->s3->tmp.new_cipher
806                != ssl_get_cipher_by_char(s, ciphdata, 0)) {
807         /*
808          * We chose a different cipher or group id this time around to what is
809          * in the cookie. Something must have changed.
810          */
811         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_CTOS_COOKIE,
812                  SSL_R_BAD_CIPHER);
813         return 0;
814     }
815
816     if (!PACKET_get_1(&cookie, &key_share)
817             || !PACKET_get_net_4(&cookie, &tm)
818             || !PACKET_get_length_prefixed_2(&cookie, &chhash)
819             || !PACKET_get_length_prefixed_1(&cookie, &appcookie)
820             || PACKET_remaining(&cookie) != SHA256_DIGEST_LENGTH) {
821         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
822                  SSL_R_LENGTH_MISMATCH);
823         return 0;
824     }
825
826     /* We tolerate a cookie age of up to 10 minutes (= 60 * 10 seconds) */
827     now = (unsigned long)time(NULL);
828     if (tm > now || (now - tm) > 600) {
829         /* Cookie is stale. Ignore it */
830         return 1;
831     }
832
833     /* Verify the app cookie */
834     if (s->ctx->app_verify_cookie_cb(s, PACKET_data(&appcookie),
835                                      PACKET_remaining(&appcookie)) == 0) {
836         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_CTOS_COOKIE,
837                  SSL_R_COOKIE_MISMATCH);
838         return 0;
839     }
840
841     /*
842      * Reconstruct the HRR that we would have sent in response to the original
843      * ClientHello so we can add it to the transcript hash.
844      * Note: This won't work with custom HRR extensions
845      */
846     if (!WPACKET_init_static_len(&hrrpkt, hrr, sizeof(hrr), 0)) {
847         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
848                  ERR_R_INTERNAL_ERROR);
849         return 0;
850     }
851     if (!WPACKET_put_bytes_u8(&hrrpkt, SSL3_MT_SERVER_HELLO)
852             || !WPACKET_start_sub_packet_u24(&hrrpkt)
853             || !WPACKET_put_bytes_u16(&hrrpkt, TLS1_2_VERSION)
854             || !WPACKET_memcpy(&hrrpkt, hrrrandom, SSL3_RANDOM_SIZE)
855             || !WPACKET_sub_memcpy_u8(&hrrpkt, s->tmp_session_id,
856                                       s->tmp_session_id_len)
857             || !s->method->put_cipher_by_char(s->s3->tmp.new_cipher, &hrrpkt,
858                                               &ciphlen)
859             || !WPACKET_put_bytes_u8(&hrrpkt, 0)
860             || !WPACKET_start_sub_packet_u16(&hrrpkt)) {
861         WPACKET_cleanup(&hrrpkt);
862         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
863                  ERR_R_INTERNAL_ERROR);
864         return 0;
865     }
866     if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_supported_versions)
867             || !WPACKET_start_sub_packet_u16(&hrrpkt)
868                /* TODO(TLS1.3): Fix this before release */
869             || !WPACKET_put_bytes_u16(&hrrpkt, TLS1_3_VERSION_DRAFT)
870             || !WPACKET_close(&hrrpkt)) {
871         WPACKET_cleanup(&hrrpkt);
872         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
873                  ERR_R_INTERNAL_ERROR);
874         return 0;
875     }
876     if (key_share) {
877         if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_key_share)
878                 || !WPACKET_start_sub_packet_u16(&hrrpkt)
879                 || !WPACKET_put_bytes_u16(&hrrpkt, s->s3->group_id)
880                 || !WPACKET_close(&hrrpkt)) {
881             WPACKET_cleanup(&hrrpkt);
882             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
883                      ERR_R_INTERNAL_ERROR);
884             return 0;
885         }
886     }
887     if (!WPACKET_put_bytes_u16(&hrrpkt, TLSEXT_TYPE_cookie)
888             || !WPACKET_start_sub_packet_u16(&hrrpkt)
889             || !WPACKET_sub_memcpy_u16(&hrrpkt, data, rawlen)
890             || !WPACKET_close(&hrrpkt) /* cookie extension */
891             || !WPACKET_close(&hrrpkt) /* extension block */
892             || !WPACKET_close(&hrrpkt) /* message */
893             || !WPACKET_get_total_written(&hrrpkt, &hrrlen)
894             || !WPACKET_finish(&hrrpkt)) {
895         WPACKET_cleanup(&hrrpkt);
896         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_COOKIE,
897                  ERR_R_INTERNAL_ERROR);
898         return 0;
899     }
900
901     /* Reconstruct the transcript hash */
902     if (!create_synthetic_message_hash(s, PACKET_data(&chhash),
903                                        PACKET_remaining(&chhash), hrr,
904                                        hrrlen)) {
905         /* SSLfatal() already called */
906         return 0;
907     }
908
909     /* Act as if this ClientHello came after a HelloRetryRequest */
910     s->hello_retry_request = 1;
911
912     s->ext.cookieok = 1;
913
914     return 1;
915 }
916
917 #ifndef OPENSSL_NO_EC
918 int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, unsigned int context,
919                                     X509 *x, size_t chainidx)
920 {
921     PACKET supported_groups_list;
922
923     /* Each group is 2 bytes and we must have at least 1. */
924     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
925             || PACKET_remaining(&supported_groups_list) == 0
926             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
927         SSLfatal(s, SSL_AD_DECODE_ERROR,
928                  SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS, SSL_R_BAD_EXTENSION);
929         return 0;
930     }
931
932     if (!s->hit || SSL_IS_TLS13(s)) {
933         OPENSSL_free(s->session->ext.supportedgroups);
934         s->session->ext.supportedgroups = NULL;
935         s->session->ext.supportedgroups_len = 0;
936         if (!tls1_save_u16(&supported_groups_list,
937                            &s->session->ext.supportedgroups,
938                            &s->session->ext.supportedgroups_len)) {
939             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
940                      SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS,
941                      ERR_R_INTERNAL_ERROR);
942             return 0;
943         }
944     }
945
946     return 1;
947 }
948 #endif
949
950 int tls_parse_ctos_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
951                        size_t chainidx)
952 {
953     /* The extension must always be empty */
954     if (PACKET_remaining(pkt) != 0) {
955         SSLfatal(s, SSL_AD_DECODE_ERROR,
956                  SSL_F_TLS_PARSE_CTOS_EMS, SSL_R_BAD_EXTENSION);
957         return 0;
958     }
959
960     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
961
962     return 1;
963 }
964
965
966 int tls_parse_ctos_early_data(SSL *s, PACKET *pkt, unsigned int context,
967                               X509 *x, size_t chainidx)
968 {
969     if (PACKET_remaining(pkt) != 0) {
970         SSLfatal(s, SSL_AD_DECODE_ERROR,
971                  SSL_F_TLS_PARSE_CTOS_EARLY_DATA, SSL_R_BAD_EXTENSION);
972         return 0;
973     }
974
975     if (s->hello_retry_request != SSL_HRR_NONE) {
976         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
977                  SSL_F_TLS_PARSE_CTOS_EARLY_DATA, SSL_R_BAD_EXTENSION);
978         return 0;
979     }
980
981     return 1;
982 }
983
984 int tls_parse_ctos_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
985                        size_t chainidx)
986 {
987     PACKET identities, binders, binder;
988     size_t binderoffset, hashsize;
989     SSL_SESSION *sess = NULL;
990     unsigned int id, i, ext = 0;
991     const EVP_MD *md = NULL;
992
993     /*
994      * If we have no PSK kex mode that we recognise then we can't resume so
995      * ignore this extension
996      */
997     if ((s->ext.psk_kex_mode
998             & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0)
999         return 1;
1000
1001     if (!PACKET_get_length_prefixed_2(pkt, &identities)) {
1002         SSLfatal(s, SSL_AD_DECODE_ERROR,
1003                  SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
1004         return 0;
1005     }
1006
1007     for (id = 0; PACKET_remaining(&identities) != 0; id++) {
1008         PACKET identity;
1009         unsigned long ticket_agel;
1010
1011         if (!PACKET_get_length_prefixed_2(&identities, &identity)
1012                 || !PACKET_get_net_4(&identities, &ticket_agel)) {
1013             SSLfatal(s, SSL_AD_DECODE_ERROR,
1014                      SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
1015             return 0;
1016         }
1017
1018         if (s->psk_find_session_cb != NULL
1019                 && !s->psk_find_session_cb(s, PACKET_data(&identity),
1020                                            PACKET_remaining(&identity),
1021                                            &sess)) {
1022             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1023                      SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
1024             return 0;
1025         }
1026
1027         if (sess != NULL) {
1028             /* We found a PSK */
1029             SSL_SESSION *sesstmp = ssl_session_dup(sess, 0);
1030
1031             if (sesstmp == NULL) {
1032                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1033                          SSL_F_TLS_PARSE_CTOS_PSK, ERR_R_INTERNAL_ERROR);
1034                 return 0;
1035             }
1036             SSL_SESSION_free(sess);
1037             sess = sesstmp;
1038
1039             /*
1040              * We've just been told to use this session for this context so
1041              * make sure the sid_ctx matches up.
1042              */
1043             memcpy(sess->sid_ctx, s->sid_ctx, s->sid_ctx_length);
1044             sess->sid_ctx_length = s->sid_ctx_length;
1045             ext = 1;
1046             if (id == 0)
1047                 s->ext.early_data_ok = 1;
1048         } else {
1049             uint32_t ticket_age = 0, now, agesec, agems;
1050             int ret = tls_decrypt_ticket(s, PACKET_data(&identity),
1051                                          PACKET_remaining(&identity), NULL, 0,
1052                                          &sess);
1053
1054             if (ret == TICKET_FATAL_ERR_MALLOC
1055                     || ret == TICKET_FATAL_ERR_OTHER) {
1056                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1057                          SSL_F_TLS_PARSE_CTOS_PSK, ERR_R_INTERNAL_ERROR);
1058                 return 0;
1059             }
1060             if (ret == TICKET_NO_DECRYPT)
1061                 continue;
1062
1063             ticket_age = (uint32_t)ticket_agel;
1064             now = (uint32_t)time(NULL);
1065             agesec = now - (uint32_t)sess->time;
1066             agems = agesec * (uint32_t)1000;
1067             ticket_age -= sess->ext.tick_age_add;
1068
1069             /*
1070              * For simplicity we do our age calculations in seconds. If the
1071              * client does it in ms then it could appear that their ticket age
1072              * is longer than ours (our ticket age calculation should always be
1073              * slightly longer than the client's due to the network latency).
1074              * Therefore we add 1000ms to our age calculation to adjust for
1075              * rounding errors.
1076              */
1077             if (id == 0
1078                     && sess->timeout >= (long)agesec
1079                     && agems / (uint32_t)1000 == agesec
1080                     && ticket_age <= agems + 1000
1081                     && ticket_age + TICKET_AGE_ALLOWANCE >= agems + 1000) {
1082                 /*
1083                  * Ticket age is within tolerance and not expired. We allow it
1084                  * for early data
1085                  */
1086                 s->ext.early_data_ok = 1;
1087             }
1088         }
1089
1090         md = ssl_md(sess->cipher->algorithm2);
1091         if (md != ssl_md(s->s3->tmp.new_cipher->algorithm2)) {
1092             /* The ciphersuite is not compatible with this session. */
1093             SSL_SESSION_free(sess);
1094             sess = NULL;
1095             s->ext.early_data_ok = 0;
1096             continue;
1097         }
1098         break;
1099     }
1100
1101     if (sess == NULL)
1102         return 1;
1103
1104     binderoffset = PACKET_data(pkt) - (const unsigned char *)s->init_buf->data;
1105     hashsize = EVP_MD_size(md);
1106
1107     if (!PACKET_get_length_prefixed_2(pkt, &binders)) {
1108         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
1109                  SSL_R_BAD_EXTENSION);
1110         goto err;
1111     }
1112
1113     for (i = 0; i <= id; i++) {
1114         if (!PACKET_get_length_prefixed_1(&binders, &binder)) {
1115             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
1116                      SSL_R_BAD_EXTENSION);
1117             goto err;
1118         }
1119     }
1120
1121     if (PACKET_remaining(&binder) != hashsize) {
1122         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
1123                  SSL_R_BAD_EXTENSION);
1124         goto err;
1125     }
1126     if (tls_psk_do_binder(s, md, (const unsigned char *)s->init_buf->data,
1127                           binderoffset, PACKET_data(&binder), NULL, sess, 0,
1128                           ext) != 1) {
1129         /* SSLfatal() already called */
1130         goto err;
1131     }
1132
1133     sess->ext.tick_identity = id;
1134
1135     SSL_SESSION_free(s->session);
1136     s->session = sess;
1137     return 1;
1138 err:
1139     SSL_SESSION_free(sess);
1140     return 0;
1141 }
1142
1143 /*
1144  * Add the server's renegotiation binding
1145  */
1146 EXT_RETURN tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt,
1147                                           unsigned int context, X509 *x,
1148                                           size_t chainidx)
1149 {
1150     if (!s->s3->send_connection_binding)
1151         return EXT_RETURN_NOT_SENT;
1152
1153     /* Still add this even if SSL_OP_NO_RENEGOTIATION is set */
1154     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
1155             || !WPACKET_start_sub_packet_u16(pkt)
1156             || !WPACKET_start_sub_packet_u8(pkt)
1157             || !WPACKET_memcpy(pkt, s->s3->previous_client_finished,
1158                                s->s3->previous_client_finished_len)
1159             || !WPACKET_memcpy(pkt, s->s3->previous_server_finished,
1160                                s->s3->previous_server_finished_len)
1161             || !WPACKET_close(pkt)
1162             || !WPACKET_close(pkt)) {
1163         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE,
1164                  ERR_R_INTERNAL_ERROR);
1165         return EXT_RETURN_FAIL;
1166     }
1167
1168     return EXT_RETURN_SENT;
1169 }
1170
1171 EXT_RETURN tls_construct_stoc_server_name(SSL *s, WPACKET *pkt,
1172                                           unsigned int context, X509 *x,
1173                                           size_t chainidx)
1174 {
1175     if (s->hit || s->servername_done != 1
1176             || s->session->ext.hostname == NULL)
1177         return EXT_RETURN_NOT_SENT;
1178
1179     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
1180             || !WPACKET_put_bytes_u16(pkt, 0)) {
1181         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME,
1182                  ERR_R_INTERNAL_ERROR);
1183         return EXT_RETURN_FAIL;
1184     }
1185
1186     return EXT_RETURN_SENT;
1187 }
1188
1189 /* Add/include the server's max fragment len extension into ServerHello */
1190 EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL *s, WPACKET *pkt,
1191                                              unsigned int context, X509 *x,
1192                                              size_t chainidx)
1193 {
1194     if (!USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
1195         return EXT_RETURN_NOT_SENT;
1196
1197     /*-
1198      * 4 bytes for this extension type and extension length
1199      * 1 byte for the Max Fragment Length code value.
1200      */
1201     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length)
1202         || !WPACKET_start_sub_packet_u16(pkt)
1203         || !WPACKET_put_bytes_u8(pkt, s->session->ext.max_fragment_len_mode)
1204         || !WPACKET_close(pkt)) {
1205         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1206                  SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN, ERR_R_INTERNAL_ERROR);
1207         return EXT_RETURN_FAIL;
1208     }
1209
1210     return EXT_RETURN_SENT;
1211 }
1212
1213 #ifndef OPENSSL_NO_EC
1214 EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt,
1215                                             unsigned int context, X509 *x,
1216                                             size_t chainidx)
1217 {
1218     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1219     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1220     int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
1221                     && (s->session->ext.ecpointformats != NULL);
1222     const unsigned char *plist;
1223     size_t plistlen;
1224
1225     if (!using_ecc)
1226         return EXT_RETURN_NOT_SENT;
1227
1228     tls1_get_formatlist(s, &plist, &plistlen);
1229     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
1230             || !WPACKET_start_sub_packet_u16(pkt)
1231             || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
1232             || !WPACKET_close(pkt)) {
1233         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1234                  SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
1235         return EXT_RETURN_FAIL;
1236     }
1237
1238     return EXT_RETURN_SENT;
1239 }
1240 #endif
1241
1242 #ifndef OPENSSL_NO_EC
1243 EXT_RETURN tls_construct_stoc_supported_groups(SSL *s, WPACKET *pkt,
1244                                                unsigned int context, X509 *x,
1245                                                size_t chainidx)
1246 {
1247     const uint16_t *groups;
1248     size_t numgroups, i, first = 1;
1249
1250     /* s->s3->group_id is non zero if we accepted a key_share */
1251     if (s->s3->group_id == 0)
1252         return EXT_RETURN_NOT_SENT;
1253
1254     /* Get our list of supported groups */
1255     tls1_get_supported_groups(s, &groups, &numgroups);
1256     if (numgroups == 0) {
1257         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1258                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS, ERR_R_INTERNAL_ERROR);
1259         return EXT_RETURN_FAIL;
1260     }
1261
1262     /* Copy group ID if supported */
1263     for (i = 0; i < numgroups; i++) {
1264         uint16_t group = groups[i];
1265
1266         if (tls_curve_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) {
1267             if (first) {
1268                 /*
1269                  * Check if the client is already using our preferred group. If
1270                  * so we don't need to add this extension
1271                  */
1272                 if (s->s3->group_id == group)
1273                     return EXT_RETURN_NOT_SENT;
1274
1275                 /* Add extension header */
1276                 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1277                            /* Sub-packet for supported_groups extension */
1278                         || !WPACKET_start_sub_packet_u16(pkt)
1279                         || !WPACKET_start_sub_packet_u16(pkt)) {
1280                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1281                              SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1282                              ERR_R_INTERNAL_ERROR);
1283                     return EXT_RETURN_FAIL;
1284                 }
1285
1286                 first = 0;
1287             }
1288             if (!WPACKET_put_bytes_u16(pkt, group)) {
1289                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1290                              SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1291                              ERR_R_INTERNAL_ERROR);
1292                     return EXT_RETURN_FAIL;
1293                 }
1294         }
1295     }
1296
1297     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1298         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1299                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1300                  ERR_R_INTERNAL_ERROR);
1301         return EXT_RETURN_FAIL;
1302     }
1303
1304     return EXT_RETURN_SENT;
1305 }
1306 #endif
1307
1308 EXT_RETURN tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt,
1309                                              unsigned int context, X509 *x,
1310                                              size_t chainidx)
1311 {
1312     if (!s->ext.ticket_expected || !tls_use_ticket(s)) {
1313         s->ext.ticket_expected = 0;
1314         return EXT_RETURN_NOT_SENT;
1315     }
1316
1317     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1318             || !WPACKET_put_bytes_u16(pkt, 0)) {
1319         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1320                  SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
1321         return EXT_RETURN_FAIL;
1322     }
1323
1324     return EXT_RETURN_SENT;
1325 }
1326
1327 #ifndef OPENSSL_NO_OCSP
1328 EXT_RETURN tls_construct_stoc_status_request(SSL *s, WPACKET *pkt,
1329                                              unsigned int context, X509 *x,
1330                                              size_t chainidx)
1331 {
1332     if (!s->ext.status_expected)
1333         return EXT_RETURN_NOT_SENT;
1334
1335     if (SSL_IS_TLS13(s) && chainidx != 0)
1336         return EXT_RETURN_NOT_SENT;
1337
1338     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1339             || !WPACKET_start_sub_packet_u16(pkt)) {
1340         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1341                  SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
1342         return EXT_RETURN_FAIL;
1343     }
1344
1345     /*
1346      * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we
1347      * send back an empty extension, with the certificate status appearing as a
1348      * separate message
1349      */
1350     if (SSL_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) {
1351        /* SSLfatal() already called */
1352        return EXT_RETURN_FAIL;
1353     }
1354     if (!WPACKET_close(pkt)) {
1355         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1356                  SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
1357         return EXT_RETURN_FAIL;
1358     }
1359
1360     return EXT_RETURN_SENT;
1361 }
1362 #endif
1363
1364 #ifndef OPENSSL_NO_NEXTPROTONEG
1365 EXT_RETURN tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt,
1366                                              unsigned int context, X509 *x,
1367                                              size_t chainidx)
1368 {
1369     const unsigned char *npa;
1370     unsigned int npalen;
1371     int ret;
1372     int npn_seen = s->s3->npn_seen;
1373
1374     s->s3->npn_seen = 0;
1375     if (!npn_seen || s->ctx->ext.npn_advertised_cb == NULL)
1376         return EXT_RETURN_NOT_SENT;
1377
1378     ret = s->ctx->ext.npn_advertised_cb(s, &npa, &npalen,
1379                                         s->ctx->ext.npn_advertised_cb_arg);
1380     if (ret == SSL_TLSEXT_ERR_OK) {
1381         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1382                 || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1383             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1384                      SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG,
1385                      ERR_R_INTERNAL_ERROR);
1386             return EXT_RETURN_FAIL;
1387         }
1388         s->s3->npn_seen = 1;
1389     }
1390
1391     return EXT_RETURN_SENT;
1392 }
1393 #endif
1394
1395 EXT_RETURN tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, unsigned int context,
1396                                    X509 *x, size_t chainidx)
1397 {
1398     if (s->s3->alpn_selected == NULL)
1399         return EXT_RETURN_NOT_SENT;
1400
1401     if (!WPACKET_put_bytes_u16(pkt,
1402                 TLSEXT_TYPE_application_layer_protocol_negotiation)
1403             || !WPACKET_start_sub_packet_u16(pkt)
1404             || !WPACKET_start_sub_packet_u16(pkt)
1405             || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1406                                       s->s3->alpn_selected_len)
1407             || !WPACKET_close(pkt)
1408             || !WPACKET_close(pkt)) {
1409         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1410                  SSL_F_TLS_CONSTRUCT_STOC_ALPN, ERR_R_INTERNAL_ERROR);
1411         return EXT_RETURN_FAIL;
1412     }
1413
1414     return EXT_RETURN_SENT;
1415 }
1416
1417 #ifndef OPENSSL_NO_SRTP
1418 EXT_RETURN tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt,
1419                                        unsigned int context, X509 *x,
1420                                        size_t chainidx)
1421 {
1422     if (s->srtp_profile == NULL)
1423         return EXT_RETURN_NOT_SENT;
1424
1425     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1426             || !WPACKET_start_sub_packet_u16(pkt)
1427             || !WPACKET_put_bytes_u16(pkt, 2)
1428             || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1429             || !WPACKET_put_bytes_u8(pkt, 0)
1430             || !WPACKET_close(pkt)) {
1431         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP,
1432                  ERR_R_INTERNAL_ERROR);
1433         return EXT_RETURN_FAIL;
1434     }
1435
1436     return EXT_RETURN_SENT;
1437 }
1438 #endif
1439
1440 EXT_RETURN tls_construct_stoc_etm(SSL *s, WPACKET *pkt, unsigned int context,
1441                                   X509 *x, size_t chainidx)
1442 {
1443     if (!s->ext.use_etm)
1444         return EXT_RETURN_NOT_SENT;
1445
1446     /*
1447      * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1448      * for other cases too.
1449      */
1450     if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1451         || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1452         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1453         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12) {
1454         s->ext.use_etm = 0;
1455         return EXT_RETURN_NOT_SENT;
1456     }
1457
1458     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1459             || !WPACKET_put_bytes_u16(pkt, 0)) {
1460         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_ETM,
1461                  ERR_R_INTERNAL_ERROR);
1462         return EXT_RETURN_FAIL;
1463     }
1464
1465     return EXT_RETURN_SENT;
1466 }
1467
1468 EXT_RETURN tls_construct_stoc_ems(SSL *s, WPACKET *pkt, unsigned int context,
1469                                   X509 *x, size_t chainidx)
1470 {
1471     if ((s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
1472         return EXT_RETURN_NOT_SENT;
1473
1474     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1475             || !WPACKET_put_bytes_u16(pkt, 0)) {
1476         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_EMS,
1477                  ERR_R_INTERNAL_ERROR);
1478         return EXT_RETURN_FAIL;
1479     }
1480
1481     return EXT_RETURN_SENT;
1482 }
1483
1484 EXT_RETURN tls_construct_stoc_supported_versions(SSL *s, WPACKET *pkt,
1485                                                  unsigned int context, X509 *x,
1486                                                  size_t chainidx)
1487 {
1488     if (!SSL_IS_TLS13(s))
1489         return EXT_RETURN_NOT_SENT;
1490
1491     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1492             || !WPACKET_start_sub_packet_u16(pkt)
1493                 /* TODO(TLS1.3): Update to remove the TLSv1.3 draft indicator */
1494             || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)
1495             || !WPACKET_close(pkt)) {
1496         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1497                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS,
1498                  ERR_R_INTERNAL_ERROR);
1499         return EXT_RETURN_FAIL;
1500     }
1501
1502     return EXT_RETURN_SENT;
1503 }
1504
1505 EXT_RETURN tls_construct_stoc_key_share(SSL *s, WPACKET *pkt,
1506                                         unsigned int context, X509 *x,
1507                                         size_t chainidx)
1508 {
1509 #ifndef OPENSSL_NO_TLS1_3
1510     unsigned char *encodedPoint;
1511     size_t encoded_pt_len = 0;
1512     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
1513
1514     if (s->hello_retry_request == SSL_HRR_PENDING) {
1515         if (ckey != NULL) {
1516             /* Original key_share was acceptable so don't ask for another one */
1517             return EXT_RETURN_NOT_SENT;
1518         }
1519         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1520                 || !WPACKET_start_sub_packet_u16(pkt)
1521                 || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)
1522                 || !WPACKET_close(pkt)) {
1523             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1524                      SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1525                      ERR_R_INTERNAL_ERROR);
1526             return EXT_RETURN_FAIL;
1527         }
1528
1529         return EXT_RETURN_SENT;
1530     }
1531
1532     if (ckey == NULL) {
1533         /* No key_share received from client - must be resuming */
1534         if (!s->hit || !tls13_generate_handshake_secret(s, NULL, 0)) {
1535             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1536                      SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1537             return EXT_RETURN_FAIL;
1538         }
1539         return EXT_RETURN_NOT_SENT;
1540     }
1541
1542     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1543             || !WPACKET_start_sub_packet_u16(pkt)
1544             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
1545         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1546                  SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1547         return EXT_RETURN_FAIL;
1548     }
1549
1550     skey = ssl_generate_pkey(ckey);
1551     if (skey == NULL) {
1552         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1553                  ERR_R_MALLOC_FAILURE);
1554         return EXT_RETURN_FAIL;
1555     }
1556
1557     /* Generate encoding of server key */
1558     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
1559     if (encoded_pt_len == 0) {
1560         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1561                  ERR_R_EC_LIB);
1562         EVP_PKEY_free(skey);
1563         return EXT_RETURN_FAIL;
1564     }
1565
1566     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
1567             || !WPACKET_close(pkt)) {
1568         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1569                  ERR_R_INTERNAL_ERROR);
1570         EVP_PKEY_free(skey);
1571         OPENSSL_free(encodedPoint);
1572         return EXT_RETURN_FAIL;
1573     }
1574     OPENSSL_free(encodedPoint);
1575
1576     /* This causes the crypto state to be updated based on the derived keys */
1577     s->s3->tmp.pkey = skey;
1578     if (ssl_derive(s, skey, ckey, 1) == 0) {
1579         /* SSLfatal() already called */
1580         return EXT_RETURN_FAIL;
1581     }
1582 #endif
1583
1584     return EXT_RETURN_SENT;
1585 }
1586
1587 EXT_RETURN tls_construct_stoc_cookie(SSL *s, WPACKET *pkt, unsigned int context,
1588                                      X509 *x, size_t chainidx)
1589 {
1590     unsigned char *hashval1, *hashval2, *appcookie1, *appcookie2, *cookie;
1591     unsigned char *hmac, *hmac2;
1592     size_t startlen, ciphlen, totcookielen, hashlen, hmaclen;
1593     unsigned int appcookielen;
1594     EVP_MD_CTX *hctx;
1595     EVP_PKEY *pkey;
1596     int ret = EXT_RETURN_FAIL;
1597
1598     if (s->ctx->app_gen_cookie_cb == NULL
1599             || (s->s3->flags & TLS1_FLAGS_STATELESS) == 0)
1600         return EXT_RETURN_NOT_SENT;
1601
1602     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie)
1603             || !WPACKET_start_sub_packet_u16(pkt)
1604             || !WPACKET_start_sub_packet_u16(pkt)
1605             || !WPACKET_get_total_written(pkt, &startlen)
1606             || !WPACKET_reserve_bytes(pkt, MAX_COOKIE_SIZE, &cookie)
1607             || !WPACKET_put_bytes_u16(pkt, COOKIE_STATE_FORMAT_VERSION)
1608             || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION)
1609             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)
1610             || !s->method->put_cipher_by_char(s->s3->tmp.new_cipher, pkt,
1611                                               &ciphlen)
1612                /* Is there a key_share extension present in this HRR? */
1613             || !WPACKET_put_bytes_u8(pkt, s->s3->peer_tmp == NULL)
1614             || !WPACKET_put_bytes_u32(pkt, (unsigned int)time(NULL))
1615             || !WPACKET_start_sub_packet_u16(pkt)
1616             || !WPACKET_reserve_bytes(pkt, EVP_MAX_MD_SIZE, &hashval1)) {
1617         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1618                  ERR_R_INTERNAL_ERROR);
1619         return EXT_RETURN_FAIL;
1620     }
1621
1622     /*
1623      * Get the hash of the initial ClientHello. ssl_handshake_hash() operates
1624      * on raw buffers, so we first reserve sufficient bytes (above) and then
1625      * subsequently allocate them (below)
1626      */
1627     if (!ssl3_digest_cached_records(s, 0)
1628             || !ssl_handshake_hash(s, hashval1, EVP_MAX_MD_SIZE, &hashlen)) {
1629         /* SSLfatal() already called */
1630         return EXT_RETURN_FAIL;
1631     }
1632
1633     if (!WPACKET_allocate_bytes(pkt, hashlen, &hashval2)
1634             || !ossl_assert(hashval1 == hashval2)
1635             || !WPACKET_close(pkt)
1636             || !WPACKET_start_sub_packet_u8(pkt)
1637             || !WPACKET_reserve_bytes(pkt, SSL_COOKIE_LENGTH, &appcookie1)) {
1638         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1639                  ERR_R_INTERNAL_ERROR);
1640         return EXT_RETURN_FAIL;
1641     }
1642
1643     /* Generate the application cookie */
1644     if (s->ctx->app_gen_cookie_cb(s, appcookie1, &appcookielen) == 0) {
1645         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1646                  SSL_R_COOKIE_GEN_CALLBACK_FAILURE);
1647         return EXT_RETURN_FAIL;
1648     }
1649
1650     if (!WPACKET_allocate_bytes(pkt, appcookielen, &appcookie2)
1651             || !ossl_assert(appcookie1 == appcookie2)
1652             || !WPACKET_close(pkt)
1653             || !WPACKET_get_total_written(pkt, &totcookielen)
1654             || !WPACKET_reserve_bytes(pkt, SHA256_DIGEST_LENGTH, &hmac)) {
1655         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1656                  ERR_R_INTERNAL_ERROR);
1657         return EXT_RETURN_FAIL;
1658     }
1659     hmaclen = SHA256_DIGEST_LENGTH;
1660
1661     totcookielen -= startlen;
1662     if (!ossl_assert(totcookielen <= MAX_COOKIE_SIZE - SHA256_DIGEST_LENGTH)) {
1663         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1664                  ERR_R_INTERNAL_ERROR);
1665         return EXT_RETURN_FAIL;
1666     }
1667
1668     /* HMAC the cookie */
1669     hctx = EVP_MD_CTX_create();
1670     pkey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL,
1671                                 s->session_ctx->ext.cookie_hmac_key,
1672                                 sizeof(s->session_ctx->ext.cookie_hmac_key));
1673     if (hctx == NULL || pkey == NULL) {
1674         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1675                  ERR_R_MALLOC_FAILURE);
1676         goto err;
1677     }
1678
1679     if (EVP_DigestSignInit(hctx, NULL, EVP_sha256(), NULL, pkey) <= 0
1680             || EVP_DigestSign(hctx, hmac, &hmaclen, cookie,
1681                               totcookielen) <= 0) {
1682         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1683                  ERR_R_INTERNAL_ERROR);
1684         goto err;
1685     }
1686
1687     if (!ossl_assert(totcookielen + hmaclen <= MAX_COOKIE_SIZE)) {
1688         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1689                  ERR_R_INTERNAL_ERROR);
1690         goto err;
1691     }
1692
1693     if (!WPACKET_allocate_bytes(pkt, hmaclen, &hmac2)
1694             || !ossl_assert(hmac == hmac2)
1695             || !ossl_assert(cookie == hmac - totcookielen)
1696             || !WPACKET_close(pkt)
1697             || !WPACKET_close(pkt)) {
1698         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_COOKIE,
1699                  ERR_R_INTERNAL_ERROR);
1700         goto err;
1701     }
1702
1703     ret = EXT_RETURN_SENT;
1704
1705  err:
1706     EVP_MD_CTX_free(hctx);
1707     EVP_PKEY_free(pkey);
1708     return ret;
1709 }
1710
1711 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt,
1712                                             unsigned int context, X509 *x,
1713                                             size_t chainidx)
1714 {
1715     const unsigned char cryptopro_ext[36] = {
1716         0xfd, 0xe8,         /* 65000 */
1717         0x00, 0x20,         /* 32 bytes length */
1718         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1719         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1720         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1721         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1722     };
1723
1724     if (((s->s3->tmp.new_cipher->id & 0xFFFF) != 0x80
1725          && (s->s3->tmp.new_cipher->id & 0xFFFF) != 0x81)
1726             || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
1727         return EXT_RETURN_NOT_SENT;
1728
1729     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1730         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1731                  SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG, ERR_R_INTERNAL_ERROR);
1732         return EXT_RETURN_FAIL;
1733     }
1734
1735     return EXT_RETURN_SENT;
1736 }
1737
1738 EXT_RETURN tls_construct_stoc_early_data(SSL *s, WPACKET *pkt,
1739                                          unsigned int context, X509 *x,
1740                                          size_t chainidx)
1741 {
1742     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
1743         if (s->max_early_data == 0)
1744             return EXT_RETURN_NOT_SENT;
1745
1746         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
1747                 || !WPACKET_start_sub_packet_u16(pkt)
1748                 || !WPACKET_put_bytes_u32(pkt, s->max_early_data)
1749                 || !WPACKET_close(pkt)) {
1750             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1751                      SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA, ERR_R_INTERNAL_ERROR);
1752             return EXT_RETURN_FAIL;
1753         }
1754
1755         return EXT_RETURN_SENT;
1756     }
1757
1758     if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED)
1759         return EXT_RETURN_NOT_SENT;
1760
1761     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
1762             || !WPACKET_start_sub_packet_u16(pkt)
1763             || !WPACKET_close(pkt)) {
1764         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA,
1765                  ERR_R_INTERNAL_ERROR);
1766         return EXT_RETURN_FAIL;
1767     }
1768
1769     return EXT_RETURN_SENT;
1770 }
1771
1772 EXT_RETURN tls_construct_stoc_psk(SSL *s, WPACKET *pkt, unsigned int context,
1773                                   X509 *x, size_t chainidx)
1774 {
1775     if (!s->hit)
1776         return EXT_RETURN_NOT_SENT;
1777
1778     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
1779             || !WPACKET_start_sub_packet_u16(pkt)
1780             || !WPACKET_put_bytes_u16(pkt, s->session->ext.tick_identity)
1781             || !WPACKET_close(pkt)) {
1782         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1783                  SSL_F_TLS_CONSTRUCT_STOC_PSK, ERR_R_INTERNAL_ERROR);
1784         return EXT_RETURN_FAIL;
1785     }
1786
1787     return EXT_RETURN_SENT;
1788 }