93ac98f11608bd791248c3a6974ace4b2940b012
[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
14 /*
15  * Parse the client's renegotiation binding and abort if it's not right
16  */
17 int tls_parse_ctos_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
18                                X509 *x, size_t chainidx)
19 {
20     unsigned int ilen;
21     const unsigned char *data;
22
23     /* Parse the length byte */
24     if (!PACKET_get_1(pkt, &ilen)
25         || !PACKET_get_bytes(pkt, &data, ilen)) {
26         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
27                  SSL_R_RENEGOTIATION_ENCODING_ERR);
28         return 0;
29     }
30
31     /* Check that the extension matches */
32     if (ilen != s->s3->previous_client_finished_len) {
33         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
34                  SSL_R_RENEGOTIATION_MISMATCH);
35         return 0;
36     }
37
38     if (memcmp(data, s->s3->previous_client_finished,
39                s->s3->previous_client_finished_len)) {
40         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
41                  SSL_R_RENEGOTIATION_MISMATCH);
42         return 0;
43     }
44
45     s->s3->send_connection_binding = 1;
46
47     return 1;
48 }
49
50 /*-
51  * The servername extension is treated as follows:
52  *
53  * - Only the hostname type is supported with a maximum length of 255.
54  * - The servername is rejected if too long or if it contains zeros,
55  *   in which case an fatal alert is generated.
56  * - The servername field is maintained together with the session cache.
57  * - When a session is resumed, the servername call back invoked in order
58  *   to allow the application to position itself to the right context.
59  * - The servername is acknowledged if it is new for a session or when
60  *   it is identical to a previously used for the same session.
61  *   Applications can control the behaviour.  They can at any time
62  *   set a 'desirable' servername for a new SSL object. This can be the
63  *   case for example with HTTPS when a Host: header field is received and
64  *   a renegotiation is requested. In this case, a possible servername
65  *   presented in the new client hello is only acknowledged if it matches
66  *   the value of the Host: field.
67  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
68  *   if they provide for changing an explicit servername context for the
69  *   session, i.e. when the session has been established with a servername
70  *   extension.
71  * - On session reconnect, the servername extension may be absent.
72  */
73 int tls_parse_ctos_server_name(SSL *s, PACKET *pkt, unsigned int context,
74                                X509 *x, size_t chainidx)
75 {
76     unsigned int servname_type;
77     PACKET sni, hostname;
78
79     if (!PACKET_as_length_prefixed_2(pkt, &sni)
80         /* ServerNameList must be at least 1 byte long. */
81         || PACKET_remaining(&sni) == 0) {
82         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
83                  SSL_R_BAD_EXTENSION);
84         return 0;
85     }
86
87     /*
88      * Although the intent was for server_name to be extensible, RFC 4366
89      * was not clear about it; and so OpenSSL among other implementations,
90      * always and only allows a 'host_name' name types.
91      * RFC 6066 corrected the mistake but adding new name types
92      * is nevertheless no longer feasible, so act as if no other
93      * SNI types can exist, to simplify parsing.
94      *
95      * Also note that the RFC permits only one SNI value per type,
96      * i.e., we can only have a single hostname.
97      */
98     if (!PACKET_get_1(&sni, &servname_type)
99         || servname_type != TLSEXT_NAMETYPE_host_name
100         || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
101         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
102                  SSL_R_BAD_EXTENSION);
103         return 0;
104     }
105
106     if (!s->hit) {
107         if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
108             SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME,
109                      SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
110                      SSL_R_BAD_EXTENSION);
111             return 0;
112         }
113
114         if (PACKET_contains_zero_byte(&hostname)) {
115             SSLfatal(s, SSL_AD_UNRECOGNIZED_NAME,
116                      SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
117                      SSL_R_BAD_EXTENSION);
118             return 0;
119         }
120
121         OPENSSL_free(s->session->ext.hostname);
122         s->session->ext.hostname = NULL;
123         if (!PACKET_strndup(&hostname, &s->session->ext.hostname)) {
124             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_SERVER_NAME,
125                      ERR_R_INTERNAL_ERROR);
126             return 0;
127         }
128
129         s->servername_done = 1;
130     } else {
131         /*
132          * TODO(openssl-team): if the SNI doesn't match, we MUST
133          * fall back to a full handshake.
134          */
135         s->servername_done = s->session->ext.hostname
136             && PACKET_equal(&hostname, s->session->ext.hostname,
137                             strlen(s->session->ext.hostname));
138
139         if (!s->servername_done && s->session->ext.hostname != NULL)
140             s->ext.early_data_ok = 0;
141     }
142
143     return 1;
144 }
145
146 int tls_parse_ctos_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
147                                   X509 *x, size_t chainidx)
148 {
149     unsigned int value;
150
151     if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) {
152         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
153                  SSL_R_BAD_EXTENSION);
154         return 0;
155     }
156
157     /* Received |value| should be a valid max-fragment-length code. */
158     if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) {
159         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
160                  SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
161                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
162         return 0;
163     }
164
165     /*
166      * RFC 6066:  The negotiated length applies for the duration of the session
167      * including session resumptions.
168      * We should receive the same code as in resumed session !
169      */
170     if (s->hit && s->session->ext.max_fragment_len_mode != value) {
171         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
172                  SSL_F_TLS_PARSE_CTOS_MAXFRAGMENTLEN,
173                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
174         return 0;
175     }
176
177     /*
178      * Store it in session, so it'll become binding for us
179      * and we'll include it in a next Server Hello.
180      */
181     s->session->ext.max_fragment_len_mode = value;
182     return 1;
183 }
184
185 #ifndef OPENSSL_NO_SRP
186 int tls_parse_ctos_srp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
187                        size_t chainidx)
188 {
189     PACKET srp_I;
190
191     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
192             || PACKET_contains_zero_byte(&srp_I)) {
193         SSLfatal(s, SSL_AD_DECODE_ERROR,
194                  SSL_F_TLS_PARSE_CTOS_SRP,
195                  SSL_R_BAD_EXTENSION);
196         return 0;
197     }
198
199     /*
200      * TODO(openssl-team): currently, we re-authenticate the user
201      * upon resumption. Instead, we MUST ignore the login.
202      */
203     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
204         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_SRP,
205                  ERR_R_INTERNAL_ERROR);
206         return 0;
207     }
208
209     return 1;
210 }
211 #endif
212
213 #ifndef OPENSSL_NO_EC
214 int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
215                                  X509 *x, size_t chainidx)
216 {
217     PACKET ec_point_format_list;
218
219     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
220         || PACKET_remaining(&ec_point_format_list) == 0) {
221         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS,
222                  SSL_R_BAD_EXTENSION);
223         return 0;
224     }
225
226     if (!s->hit) {
227         if (!PACKET_memdup(&ec_point_format_list,
228                            &s->session->ext.ecpointformats,
229                            &s->session->ext.ecpointformats_len)) {
230             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
231                      SSL_F_TLS_PARSE_CTOS_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
232             return 0;
233         }
234     }
235
236     return 1;
237 }
238 #endif                          /* OPENSSL_NO_EC */
239
240 int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
241                                   X509 *x, size_t chainidx)
242 {
243     if (s->ext.session_ticket_cb &&
244             !s->ext.session_ticket_cb(s, PACKET_data(pkt),
245                                   PACKET_remaining(pkt),
246                                   s->ext.session_ticket_cb_arg)) {
247         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
248                  SSL_F_TLS_PARSE_CTOS_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
249         return 0;
250     }
251
252     return 1;
253 }
254
255 int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
256                             size_t chainidx)
257 {
258     PACKET supported_sig_algs;
259
260     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
261             || PACKET_remaining(&supported_sig_algs) == 0) {
262         SSLfatal(s, SSL_AD_DECODE_ERROR,
263                  SSL_F_TLS_PARSE_CTOS_SIG_ALGS, SSL_R_BAD_EXTENSION);
264         return 0;
265     }
266
267     if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs)) {
268         SSLfatal(s, SSL_AD_DECODE_ERROR,
269                  SSL_F_TLS_PARSE_CTOS_SIG_ALGS, SSL_R_BAD_EXTENSION);
270         return 0;
271     }
272
273     return 1;
274 }
275
276 #ifndef OPENSSL_NO_OCSP
277 int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, unsigned int context,
278                                   X509 *x, size_t chainidx)
279 {
280     PACKET responder_id_list, exts;
281
282     /* Not defined if we get one of these in a client Certificate */
283     if (x != NULL)
284         return 1;
285
286     if (!PACKET_get_1(pkt, (unsigned int *)&s->ext.status_type)) {
287         SSLfatal(s, SSL_AD_DECODE_ERROR,
288                  SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
289         return 0;
290     }
291
292     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
293         /*
294          * We don't know what to do with any other type so ignore it.
295          */
296         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
297         return 1;
298     }
299
300     if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
301         SSLfatal(s, SSL_AD_DECODE_ERROR,
302                  SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
303         return 0;
304     }
305
306     /*
307      * We remove any OCSP_RESPIDs from a previous handshake
308      * to prevent unbounded memory growth - CVE-2016-6304
309      */
310     sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
311     if (PACKET_remaining(&responder_id_list) > 0) {
312         s->ext.ocsp.ids = sk_OCSP_RESPID_new_null();
313         if (s->ext.ocsp.ids == NULL) {
314             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
315                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, ERR_R_MALLOC_FAILURE);
316             return 0;
317         }
318     } else {
319         s->ext.ocsp.ids = NULL;
320     }
321
322     while (PACKET_remaining(&responder_id_list) > 0) {
323         OCSP_RESPID *id;
324         PACKET responder_id;
325         const unsigned char *id_data;
326
327         if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id)
328                 || PACKET_remaining(&responder_id) == 0) {
329             SSLfatal(s, SSL_AD_DECODE_ERROR,
330                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
331             return 0;
332         }
333
334         id_data = PACKET_data(&responder_id);
335         /* TODO(size_t): Convert d2i_* to size_t */
336         id = d2i_OCSP_RESPID(NULL, &id_data,
337                              (int)PACKET_remaining(&responder_id));
338         if (id == NULL) {
339             SSLfatal(s, SSL_AD_DECODE_ERROR,
340                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
341             return 0;
342         }
343
344         if (id_data != PACKET_end(&responder_id)) {
345             OCSP_RESPID_free(id);
346             SSLfatal(s, SSL_AD_DECODE_ERROR,
347                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
348
349             return 0;
350         }
351
352         if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) {
353             OCSP_RESPID_free(id);
354             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
355                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
356
357             return 0;
358         }
359     }
360
361     /* Read in request_extensions */
362     if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
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 (PACKET_remaining(&exts) > 0) {
369         const unsigned char *ext_data = PACKET_data(&exts);
370
371         sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts,
372                                    X509_EXTENSION_free);
373         s->ext.ocsp.exts =
374             d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
375         if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) {
376             SSLfatal(s, SSL_AD_DECODE_ERROR,
377                      SSL_F_TLS_PARSE_CTOS_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
378             return 0;
379         }
380     }
381
382     return 1;
383 }
384 #endif
385
386 #ifndef OPENSSL_NO_NEXTPROTONEG
387 int tls_parse_ctos_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
388                        size_t chainidx)
389 {
390     /*
391      * We shouldn't accept this extension on a
392      * renegotiation.
393      */
394     if (SSL_IS_FIRST_HANDSHAKE(s))
395         s->s3->npn_seen = 1;
396
397     return 1;
398 }
399 #endif
400
401 /*
402  * Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN
403  * extension, not including type and length. Returns: 1 on success, 0 on error.
404  */
405 int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
406                         size_t chainidx)
407 {
408     PACKET protocol_list, save_protocol_list, protocol;
409
410     if (!SSL_IS_FIRST_HANDSHAKE(s))
411         return 1;
412
413     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
414         || PACKET_remaining(&protocol_list) < 2) {
415         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
416                  SSL_R_BAD_EXTENSION);
417         return 0;
418     }
419
420     save_protocol_list = protocol_list;
421     do {
422         /* Protocol names can't be empty. */
423         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
424                 || PACKET_remaining(&protocol) == 0) {
425             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
426                      SSL_R_BAD_EXTENSION);
427             return 0;
428         }
429     } while (PACKET_remaining(&protocol_list) != 0);
430
431     OPENSSL_free(s->s3->alpn_proposed);
432     s->s3->alpn_proposed = NULL;
433     s->s3->alpn_proposed_len = 0;
434     if (!PACKET_memdup(&save_protocol_list,
435                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
436         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_ALPN,
437                  ERR_R_INTERNAL_ERROR);
438         return 0;
439     }
440
441     return 1;
442 }
443
444 #ifndef OPENSSL_NO_SRTP
445 int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
446                             size_t chainidx)
447 {
448     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
449     unsigned int ct, mki_len, id;
450     int i, srtp_pref;
451     PACKET subpkt;
452
453     /* Ignore this if we have no SRTP profiles */
454     if (SSL_get_srtp_profiles(s) == NULL)
455         return 1;
456
457     /* Pull off the length of the cipher suite list  and check it is even */
458     if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0
459             || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
460         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
461                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
462         return 0;
463     }
464
465     srvr = SSL_get_srtp_profiles(s);
466     s->srtp_profile = NULL;
467     /* Search all profiles for a match initially */
468     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
469
470     while (PACKET_remaining(&subpkt)) {
471         if (!PACKET_get_net_2(&subpkt, &id)) {
472             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
473                      SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
474             return 0;
475         }
476
477         /*
478          * Only look for match in profiles of higher preference than
479          * current match.
480          * If no profiles have been have been configured then this
481          * does nothing.
482          */
483         for (i = 0; i < srtp_pref; i++) {
484             SRTP_PROTECTION_PROFILE *sprof =
485                 sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
486
487             if (sprof->id == id) {
488                 s->srtp_profile = sprof;
489                 srtp_pref = i;
490                 break;
491             }
492         }
493     }
494
495     /* Now extract the MKI value as a sanity check, but discard it for now */
496     if (!PACKET_get_1(pkt, &mki_len)) {
497         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
498                  SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
499         return 0;
500     }
501
502     if (!PACKET_forward(pkt, mki_len)
503         || PACKET_remaining(pkt)) {
504         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_USE_SRTP,
505                  SSL_R_BAD_SRTP_MKI_VALUE);
506         return 0;
507     }
508
509     return 1;
510 }
511 #endif
512
513 int tls_parse_ctos_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
514                        size_t chainidx)
515 {
516     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
517         s->ext.use_etm = 1;
518
519     return 1;
520 }
521
522 /*
523  * Process a psk_kex_modes extension received in the ClientHello. |pkt| contains
524  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
525  */
526 int tls_parse_ctos_psk_kex_modes(SSL *s, PACKET *pkt, unsigned int context,
527                                  X509 *x, size_t chainidx)
528 {
529 #ifndef OPENSSL_NO_TLS1_3
530     PACKET psk_kex_modes;
531     unsigned int mode;
532
533     if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes)
534             || PACKET_remaining(&psk_kex_modes) == 0) {
535         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK_KEX_MODES,
536                  SSL_R_BAD_EXTENSION);
537         return 0;
538     }
539
540     while (PACKET_get_1(&psk_kex_modes, &mode)) {
541         if (mode == TLSEXT_KEX_MODE_KE_DHE)
542             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE_DHE;
543         else if (mode == TLSEXT_KEX_MODE_KE
544                 && (s->options & SSL_OP_ALLOW_NO_DHE_KEX) != 0)
545             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
546     }
547 #endif
548
549     return 1;
550 }
551
552 /*
553  * Process a key_share extension received in the ClientHello. |pkt| contains
554  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
555  */
556 int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
557                              size_t chainidx)
558 {
559 #ifndef OPENSSL_NO_TLS1_3
560     unsigned int group_id;
561     PACKET key_share_list, encoded_pt;
562     const uint16_t *clntgroups, *srvrgroups;
563     size_t clnt_num_groups, srvr_num_groups;
564     int found = 0;
565
566     if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0)
567         return 1;
568
569     /* Sanity check */
570     if (s->s3->peer_tmp != NULL) {
571         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
572                  ERR_R_INTERNAL_ERROR);
573         return 0;
574     }
575
576     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
577         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
578                  SSL_R_LENGTH_MISMATCH);
579         return 0;
580     }
581
582     /* Get our list of supported groups */
583     tls1_get_supported_groups(s, &srvrgroups, &srvr_num_groups);
584     /* Get the clients list of supported groups. */
585     tls1_get_peer_groups(s, &clntgroups, &clnt_num_groups);
586     if (clnt_num_groups == 0) {
587         /*
588          * This can only happen if the supported_groups extension was not sent,
589          * because we verify that the length is non-zero when we process that
590          * extension.
591          */
592         SSLfatal(s, SSL_AD_MISSING_EXTENSION, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
593                  SSL_R_MISSING_SUPPORTED_GROUPS_EXTENSION);
594         return 0;
595     }
596
597     while (PACKET_remaining(&key_share_list) > 0) {
598         if (!PACKET_get_net_2(&key_share_list, &group_id)
599                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
600                 || PACKET_remaining(&encoded_pt) == 0) {
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         /*
607          * If we already found a suitable key_share we loop through the
608          * rest to verify the structure, but don't process them.
609          */
610         if (found)
611             continue;
612
613         /* Check if this share is in supported_groups sent from client */
614         if (!check_in_list(s, group_id, clntgroups, clnt_num_groups, 0)) {
615             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
616                      SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
617             return 0;
618         }
619
620         /* Check if this share is for a group we can use */
621         if (!check_in_list(s, group_id, srvrgroups, srvr_num_groups, 1)) {
622             /* Share not suitable */
623             continue;
624         }
625
626         if ((s->s3->peer_tmp = ssl_generate_param_group(group_id)) == NULL) {
627             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
628                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
629             return 0;
630         }
631
632         s->s3->group_id = group_id;
633
634         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
635                 PACKET_data(&encoded_pt),
636                 PACKET_remaining(&encoded_pt))) {
637             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
638                      SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_ECPOINT);
639             return 0;
640         }
641
642         found = 1;
643     }
644 #endif
645
646     return 1;
647 }
648
649 #ifndef OPENSSL_NO_EC
650 int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, unsigned int context,
651                                     X509 *x, size_t chainidx)
652 {
653     PACKET supported_groups_list;
654
655     /* Each group is 2 bytes and we must have at least 1. */
656     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
657             || PACKET_remaining(&supported_groups_list) == 0
658             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
659         SSLfatal(s, SSL_AD_DECODE_ERROR,
660                  SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS, SSL_R_BAD_EXTENSION);
661         return 0;
662     }
663
664     if (!s->hit || SSL_IS_TLS13(s)) {
665         OPENSSL_free(s->session->ext.supportedgroups);
666         s->session->ext.supportedgroups = NULL;
667         s->session->ext.supportedgroups_len = 0;
668         if (!tls1_save_u16(&supported_groups_list,
669                            &s->session->ext.supportedgroups,
670                            &s->session->ext.supportedgroups_len)) {
671             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
672                      SSL_F_TLS_PARSE_CTOS_SUPPORTED_GROUPS,
673                      ERR_R_INTERNAL_ERROR);
674             return 0;
675         }
676     }
677
678     return 1;
679 }
680 #endif
681
682 int tls_parse_ctos_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
683                        size_t chainidx)
684 {
685     /* The extension must always be empty */
686     if (PACKET_remaining(pkt) != 0) {
687         SSLfatal(s, SSL_AD_DECODE_ERROR,
688                  SSL_F_TLS_PARSE_CTOS_EMS, SSL_R_BAD_EXTENSION);
689         return 0;
690     }
691
692     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
693
694     return 1;
695 }
696
697
698 int tls_parse_ctos_early_data(SSL *s, PACKET *pkt, unsigned int context,
699                               X509 *x, size_t chainidx)
700 {
701     if (PACKET_remaining(pkt) != 0) {
702         SSLfatal(s, SSL_AD_DECODE_ERROR,
703                  SSL_F_TLS_PARSE_CTOS_EARLY_DATA, SSL_R_BAD_EXTENSION);
704         return 0;
705     }
706
707     if (s->hello_retry_request) {
708         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
709                  SSL_F_TLS_PARSE_CTOS_EARLY_DATA, SSL_R_BAD_EXTENSION);
710         return 0;
711     }
712
713     return 1;
714 }
715
716 int tls_parse_ctos_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
717                        size_t chainidx)
718 {
719     PACKET identities, binders, binder;
720     size_t binderoffset, hashsize;
721     SSL_SESSION *sess = NULL;
722     unsigned int id, i, ext = 0;
723     const EVP_MD *md = NULL;
724
725     /*
726      * If we have no PSK kex mode that we recognise then we can't resume so
727      * ignore this extension
728      */
729     if ((s->ext.psk_kex_mode
730             & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0)
731         return 1;
732
733     if (!PACKET_get_length_prefixed_2(pkt, &identities)) {
734         SSLfatal(s, SSL_AD_DECODE_ERROR,
735                  SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
736         return 0;
737     }
738
739     for (id = 0; PACKET_remaining(&identities) != 0; id++) {
740         PACKET identity;
741         unsigned long ticket_agel;
742
743         if (!PACKET_get_length_prefixed_2(&identities, &identity)
744                 || !PACKET_get_net_4(&identities, &ticket_agel)) {
745             SSLfatal(s, SSL_AD_DECODE_ERROR,
746                      SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
747             return 0;
748         }
749
750         if (s->psk_find_session_cb != NULL
751                 && !s->psk_find_session_cb(s, PACKET_data(&identity),
752                                            PACKET_remaining(&identity),
753                                            &sess)) {
754             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
755                      SSL_F_TLS_PARSE_CTOS_PSK, SSL_R_BAD_EXTENSION);
756             return 0;
757         }
758
759         if (sess != NULL) {
760             /* We found a PSK */
761             SSL_SESSION *sesstmp = ssl_session_dup(sess, 0);
762
763             if (sesstmp == NULL) {
764                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
765                          SSL_F_TLS_PARSE_CTOS_PSK, ERR_R_INTERNAL_ERROR);
766                 return 0;
767             }
768             SSL_SESSION_free(sess);
769             sess = sesstmp;
770
771             /*
772              * We've just been told to use this session for this context so
773              * make sure the sid_ctx matches up.
774              */
775             memcpy(sess->sid_ctx, s->sid_ctx, s->sid_ctx_length);
776             sess->sid_ctx_length = s->sid_ctx_length;
777             ext = 1;
778             if (id == 0)
779                 s->ext.early_data_ok = 1;
780         } else {
781             uint32_t ticket_age = 0, now, agesec, agems;
782             int ret = tls_decrypt_ticket(s, PACKET_data(&identity),
783                                          PACKET_remaining(&identity), NULL, 0,
784                                          &sess);
785
786             if (ret == TICKET_FATAL_ERR_MALLOC
787                     || ret == TICKET_FATAL_ERR_OTHER) {
788                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
789                          SSL_F_TLS_PARSE_CTOS_PSK, ERR_R_INTERNAL_ERROR);
790                 return 0;
791             }
792             if (ret == TICKET_NO_DECRYPT)
793                 continue;
794
795             ticket_age = (uint32_t)ticket_agel;
796             now = (uint32_t)time(NULL);
797             agesec = now - (uint32_t)sess->time;
798             agems = agesec * (uint32_t)1000;
799             ticket_age -= sess->ext.tick_age_add;
800
801             /*
802              * For simplicity we do our age calculations in seconds. If the
803              * client does it in ms then it could appear that their ticket age
804              * is longer than ours (our ticket age calculation should always be
805              * slightly longer than the client's due to the network latency).
806              * Therefore we add 1000ms to our age calculation to adjust for
807              * rounding errors.
808              */
809             if (id == 0
810                     && sess->timeout >= (long)agesec
811                     && agems / (uint32_t)1000 == agesec
812                     && ticket_age <= agems + 1000
813                     && ticket_age + TICKET_AGE_ALLOWANCE >= agems + 1000) {
814                 /*
815                  * Ticket age is within tolerance and not expired. We allow it
816                  * for early data
817                  */
818                 s->ext.early_data_ok = 1;
819             }
820         }
821
822         md = ssl_md(sess->cipher->algorithm2);
823         if (md != ssl_md(s->s3->tmp.new_cipher->algorithm2)) {
824             /* The ciphersuite is not compatible with this session. */
825             SSL_SESSION_free(sess);
826             sess = NULL;
827             s->ext.early_data_ok = 0;
828             continue;
829         }
830         break;
831     }
832
833     if (sess == NULL)
834         return 1;
835
836     binderoffset = PACKET_data(pkt) - (const unsigned char *)s->init_buf->data;
837     hashsize = EVP_MD_size(md);
838
839     if (!PACKET_get_length_prefixed_2(pkt, &binders)) {
840         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
841                  SSL_R_BAD_EXTENSION);
842         goto err;
843     }
844
845     for (i = 0; i <= id; i++) {
846         if (!PACKET_get_length_prefixed_1(&binders, &binder)) {
847             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
848                      SSL_R_BAD_EXTENSION);
849             goto err;
850         }
851     }
852
853     if (PACKET_remaining(&binder) != hashsize) {
854         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_CTOS_PSK,
855                  SSL_R_BAD_EXTENSION);
856         goto err;
857     }
858     if (tls_psk_do_binder(s, md, (const unsigned char *)s->init_buf->data,
859                           binderoffset, PACKET_data(&binder), NULL, sess, 0,
860                           ext) != 1) {
861         /* SSLfatal() already called */
862         goto err;
863     }
864
865     sess->ext.tick_identity = id;
866
867     SSL_SESSION_free(s->session);
868     s->session = sess;
869     return 1;
870 err:
871     SSL_SESSION_free(sess);
872     return 0;
873 }
874
875 /*
876  * Add the server's renegotiation binding
877  */
878 EXT_RETURN tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt,
879                                           unsigned int context, X509 *x,
880                                           size_t chainidx)
881 {
882     if (!s->s3->send_connection_binding)
883         return EXT_RETURN_NOT_SENT;
884
885     /* Still add this even if SSL_OP_NO_RENEGOTIATION is set */
886     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
887             || !WPACKET_start_sub_packet_u16(pkt)
888             || !WPACKET_start_sub_packet_u8(pkt)
889             || !WPACKET_memcpy(pkt, s->s3->previous_client_finished,
890                                s->s3->previous_client_finished_len)
891             || !WPACKET_memcpy(pkt, s->s3->previous_server_finished,
892                                s->s3->previous_server_finished_len)
893             || !WPACKET_close(pkt)
894             || !WPACKET_close(pkt)) {
895         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE,
896                  ERR_R_INTERNAL_ERROR);
897         return EXT_RETURN_FAIL;
898     }
899
900     return EXT_RETURN_SENT;
901 }
902
903 EXT_RETURN tls_construct_stoc_server_name(SSL *s, WPACKET *pkt,
904                                           unsigned int context, X509 *x,
905                                           size_t chainidx)
906 {
907     if (s->hit || s->servername_done != 1
908             || s->session->ext.hostname == NULL)
909         return EXT_RETURN_NOT_SENT;
910
911     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
912             || !WPACKET_put_bytes_u16(pkt, 0)) {
913         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME,
914                  ERR_R_INTERNAL_ERROR);
915         return EXT_RETURN_FAIL;
916     }
917
918     return EXT_RETURN_SENT;
919 }
920
921 /* Add/include the server's max fragment len extension into ServerHello */
922 EXT_RETURN tls_construct_stoc_maxfragmentlen(SSL *s, WPACKET *pkt,
923                                              unsigned int context, X509 *x,
924                                              size_t chainidx)
925 {
926     if (!USE_MAX_FRAGMENT_LENGTH_EXT(s->session))
927         return EXT_RETURN_NOT_SENT;
928
929     /*-
930      * 4 bytes for this extension type and extension length
931      * 1 byte for the Max Fragment Length code value.
932      */
933     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length)
934         || !WPACKET_start_sub_packet_u16(pkt)
935         || !WPACKET_put_bytes_u8(pkt, s->session->ext.max_fragment_len_mode)
936         || !WPACKET_close(pkt)) {
937         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
938                  SSL_F_TLS_CONSTRUCT_STOC_MAXFRAGMENTLEN, ERR_R_INTERNAL_ERROR);
939         return EXT_RETURN_FAIL;
940     }
941
942     return EXT_RETURN_SENT;
943 }
944
945 #ifndef OPENSSL_NO_EC
946 EXT_RETURN tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt,
947                                             unsigned int context, X509 *x,
948                                             size_t chainidx)
949 {
950     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
951     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
952     int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
953                     && (s->session->ext.ecpointformats != NULL);
954     const unsigned char *plist;
955     size_t plistlen;
956
957     if (!using_ecc)
958         return EXT_RETURN_NOT_SENT;
959
960     tls1_get_formatlist(s, &plist, &plistlen);
961     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
962             || !WPACKET_start_sub_packet_u16(pkt)
963             || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
964             || !WPACKET_close(pkt)) {
965         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
966                  SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
967         return EXT_RETURN_FAIL;
968     }
969
970     return EXT_RETURN_SENT;
971 }
972 #endif
973
974 #ifndef OPENSSL_NO_EC
975 EXT_RETURN tls_construct_stoc_supported_groups(SSL *s, WPACKET *pkt,
976                                                unsigned int context, X509 *x,
977                                                size_t chainidx)
978 {
979     const uint16_t *groups;
980     size_t numgroups, i, first = 1;
981
982     /* s->s3->group_id is non zero if we accepted a key_share */
983     if (s->s3->group_id == 0)
984         return EXT_RETURN_NOT_SENT;
985
986     /* Get our list of supported groups */
987     tls1_get_supported_groups(s, &groups, &numgroups);
988     if (numgroups == 0) {
989         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
990                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS, ERR_R_INTERNAL_ERROR);
991         return EXT_RETURN_FAIL;
992     }
993
994     /* Copy group ID if supported */
995     for (i = 0; i < numgroups; i++) {
996         uint16_t group = groups[i];
997
998         if (tls_curve_allowed(s, group, SSL_SECOP_CURVE_SUPPORTED)) {
999             if (first) {
1000                 /*
1001                  * Check if the client is already using our preferred group. If
1002                  * so we don't need to add this extension
1003                  */
1004                 if (s->s3->group_id == group)
1005                     return EXT_RETURN_NOT_SENT;
1006
1007                 /* Add extension header */
1008                 if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
1009                            /* Sub-packet for supported_groups extension */
1010                         || !WPACKET_start_sub_packet_u16(pkt)
1011                         || !WPACKET_start_sub_packet_u16(pkt)) {
1012                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1013                              SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1014                              ERR_R_INTERNAL_ERROR);
1015                     return EXT_RETURN_FAIL;
1016                 }
1017
1018                 first = 0;
1019             }
1020             if (!WPACKET_put_bytes_u16(pkt, group)) {
1021                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1022                              SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1023                              ERR_R_INTERNAL_ERROR);
1024                     return EXT_RETURN_FAIL;
1025                 }
1026         }
1027     }
1028
1029     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
1030         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1031                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_GROUPS,
1032                  ERR_R_INTERNAL_ERROR);
1033         return EXT_RETURN_FAIL;
1034     }
1035
1036     return EXT_RETURN_SENT;
1037 }
1038 #endif
1039
1040 EXT_RETURN tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt,
1041                                              unsigned int context, X509 *x,
1042                                              size_t chainidx)
1043 {
1044     if (!s->ext.ticket_expected || !tls_use_ticket(s)) {
1045         s->ext.ticket_expected = 0;
1046         return EXT_RETURN_NOT_SENT;
1047     }
1048
1049     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
1050             || !WPACKET_put_bytes_u16(pkt, 0)) {
1051         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1052                  SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
1053         return EXT_RETURN_FAIL;
1054     }
1055
1056     return EXT_RETURN_SENT;
1057 }
1058
1059 #ifndef OPENSSL_NO_OCSP
1060 EXT_RETURN tls_construct_stoc_status_request(SSL *s, WPACKET *pkt,
1061                                              unsigned int context, X509 *x,
1062                                              size_t chainidx)
1063 {
1064     if (!s->ext.status_expected)
1065         return EXT_RETURN_NOT_SENT;
1066
1067     if (SSL_IS_TLS13(s) && chainidx != 0)
1068         return EXT_RETURN_NOT_SENT;
1069
1070     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
1071             || !WPACKET_start_sub_packet_u16(pkt)) {
1072         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1073                  SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
1074         return EXT_RETURN_FAIL;
1075     }
1076
1077     /*
1078      * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we
1079      * send back an empty extension, with the certificate status appearing as a
1080      * separate message
1081      */
1082     if (SSL_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt)) {
1083        /* SSLfatal() already called */
1084        return EXT_RETURN_FAIL; 
1085     }
1086     if (!WPACKET_close(pkt)) {
1087         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1088                  SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
1089         return EXT_RETURN_FAIL;
1090     }
1091
1092     return EXT_RETURN_SENT;
1093 }
1094 #endif
1095
1096 #ifndef OPENSSL_NO_NEXTPROTONEG
1097 EXT_RETURN tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt,
1098                                              unsigned int context, X509 *x,
1099                                              size_t chainidx)
1100 {
1101     const unsigned char *npa;
1102     unsigned int npalen;
1103     int ret;
1104     int npn_seen = s->s3->npn_seen;
1105
1106     s->s3->npn_seen = 0;
1107     if (!npn_seen || s->ctx->ext.npn_advertised_cb == NULL)
1108         return EXT_RETURN_NOT_SENT;
1109
1110     ret = s->ctx->ext.npn_advertised_cb(s, &npa, &npalen,
1111                                         s->ctx->ext.npn_advertised_cb_arg);
1112     if (ret == SSL_TLSEXT_ERR_OK) {
1113         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
1114                 || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
1115             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1116                      SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG,
1117                      ERR_R_INTERNAL_ERROR);
1118             return EXT_RETURN_FAIL;
1119         }
1120         s->s3->npn_seen = 1;
1121     }
1122
1123     return EXT_RETURN_SENT;
1124 }
1125 #endif
1126
1127 EXT_RETURN tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, unsigned int context,
1128                                    X509 *x, size_t chainidx)
1129 {
1130     if (s->s3->alpn_selected == NULL)
1131         return EXT_RETURN_NOT_SENT;
1132
1133     if (!WPACKET_put_bytes_u16(pkt,
1134                 TLSEXT_TYPE_application_layer_protocol_negotiation)
1135             || !WPACKET_start_sub_packet_u16(pkt)
1136             || !WPACKET_start_sub_packet_u16(pkt)
1137             || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
1138                                       s->s3->alpn_selected_len)
1139             || !WPACKET_close(pkt)
1140             || !WPACKET_close(pkt)) {
1141         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1142                  SSL_F_TLS_CONSTRUCT_STOC_ALPN, ERR_R_INTERNAL_ERROR);
1143         return EXT_RETURN_FAIL;
1144     }
1145
1146     return EXT_RETURN_SENT;
1147 }
1148
1149 #ifndef OPENSSL_NO_SRTP
1150 EXT_RETURN tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt,
1151                                        unsigned int context, X509 *x,
1152                                        size_t chainidx)
1153 {
1154     if (s->srtp_profile == NULL)
1155         return EXT_RETURN_NOT_SENT;
1156
1157     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
1158             || !WPACKET_start_sub_packet_u16(pkt)
1159             || !WPACKET_put_bytes_u16(pkt, 2)
1160             || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
1161             || !WPACKET_put_bytes_u8(pkt, 0)
1162             || !WPACKET_close(pkt)) {
1163         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP,
1164                  ERR_R_INTERNAL_ERROR);
1165         return EXT_RETURN_FAIL;
1166     }
1167
1168     return EXT_RETURN_SENT;
1169 }
1170 #endif
1171
1172 EXT_RETURN tls_construct_stoc_etm(SSL *s, WPACKET *pkt, unsigned int context,
1173                                   X509 *x, size_t chainidx)
1174 {
1175     if (!s->ext.use_etm)
1176         return EXT_RETURN_NOT_SENT;
1177
1178     /*
1179      * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
1180      * for other cases too.
1181      */
1182     if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
1183         || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
1184         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
1185         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12) {
1186         s->ext.use_etm = 0;
1187         return EXT_RETURN_NOT_SENT;
1188     }
1189
1190     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1191             || !WPACKET_put_bytes_u16(pkt, 0)) {
1192         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_ETM,
1193                  ERR_R_INTERNAL_ERROR);
1194         return EXT_RETURN_FAIL;
1195     }
1196
1197     return EXT_RETURN_SENT;
1198 }
1199
1200 EXT_RETURN tls_construct_stoc_ems(SSL *s, WPACKET *pkt, unsigned int context,
1201                                   X509 *x, size_t chainidx)
1202 {
1203     if ((s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
1204         return EXT_RETURN_NOT_SENT;
1205
1206     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1207             || !WPACKET_put_bytes_u16(pkt, 0)) {
1208         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_EMS,
1209                  ERR_R_INTERNAL_ERROR);
1210         return EXT_RETURN_FAIL;
1211     }
1212
1213     return EXT_RETURN_SENT;
1214 }
1215
1216 EXT_RETURN tls_construct_stoc_supported_versions(SSL *s, WPACKET *pkt,
1217                                                  unsigned int context, X509 *x,
1218                                                  size_t chainidx)
1219 {
1220     if (!SSL_IS_TLS13(s))
1221         return EXT_RETURN_NOT_SENT;
1222
1223     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
1224             || !WPACKET_start_sub_packet_u16(pkt)
1225                 /* TODO(TLS1.3): Update to remove the TLSv1.3 draft indicator */
1226             || !WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)
1227             || !WPACKET_close(pkt)) {
1228         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1229                  SSL_F_TLS_CONSTRUCT_STOC_SUPPORTED_VERSIONS,
1230                  ERR_R_INTERNAL_ERROR);
1231         return EXT_RETURN_FAIL;
1232     }
1233
1234     return EXT_RETURN_SENT;
1235 }
1236
1237 EXT_RETURN tls_construct_stoc_key_share(SSL *s, WPACKET *pkt,
1238                                         unsigned int context, X509 *x,
1239                                         size_t chainidx)
1240 {
1241 #ifndef OPENSSL_NO_TLS1_3
1242     unsigned char *encodedPoint;
1243     size_t encoded_pt_len = 0;
1244     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
1245
1246     if (ckey == NULL) {
1247         /* No key_share received from client */
1248         if (s->hello_retry_request) {
1249             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1250                     || !WPACKET_start_sub_packet_u16(pkt)
1251                     || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)
1252                     || !WPACKET_close(pkt)) {
1253                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1254                          SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1255                          ERR_R_INTERNAL_ERROR);
1256                 return EXT_RETURN_FAIL;
1257             }
1258
1259             return EXT_RETURN_SENT;
1260         }
1261
1262         /* Must be resuming. */
1263         if (!s->hit || !tls13_generate_handshake_secret(s, NULL, 0)) {
1264             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1265                      SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1266             return EXT_RETURN_FAIL;
1267         }
1268         return EXT_RETURN_NOT_SENT;
1269     }
1270
1271     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1272             || !WPACKET_start_sub_packet_u16(pkt)
1273             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
1274         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1275                  SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1276         return EXT_RETURN_FAIL;
1277     }
1278
1279     skey = ssl_generate_pkey(ckey);
1280     if (skey == NULL) {
1281         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1282                  ERR_R_MALLOC_FAILURE);
1283         return EXT_RETURN_FAIL;
1284     }
1285
1286     /* Generate encoding of server key */
1287     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
1288     if (encoded_pt_len == 0) {
1289         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1290                  ERR_R_EC_LIB);
1291         EVP_PKEY_free(skey);
1292         return EXT_RETURN_FAIL;
1293     }
1294
1295     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
1296             || !WPACKET_close(pkt)) {
1297         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1298                  ERR_R_INTERNAL_ERROR);
1299         EVP_PKEY_free(skey);
1300         OPENSSL_free(encodedPoint);
1301         return EXT_RETURN_FAIL;
1302     }
1303     OPENSSL_free(encodedPoint);
1304
1305     /* This causes the crypto state to be updated based on the derived keys */
1306     s->s3->tmp.pkey = skey;
1307     if (ssl_derive(s, skey, ckey, 1) == 0) {
1308         /* SSLfatal() already called */
1309         return EXT_RETURN_FAIL;
1310     }
1311 #endif
1312
1313     return EXT_RETURN_SENT;
1314 }
1315
1316 EXT_RETURN tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt,
1317                                             unsigned int context, X509 *x,
1318                                             size_t chainidx)
1319 {
1320     const unsigned char cryptopro_ext[36] = {
1321         0xfd, 0xe8,         /* 65000 */
1322         0x00, 0x20,         /* 32 bytes length */
1323         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1324         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1325         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1326         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1327     };
1328
1329     if (((s->s3->tmp.new_cipher->id & 0xFFFF) != 0x80
1330          && (s->s3->tmp.new_cipher->id & 0xFFFF) != 0x81)
1331             || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
1332         return EXT_RETURN_NOT_SENT;
1333
1334     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1335         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1336                  SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG, ERR_R_INTERNAL_ERROR);
1337         return EXT_RETURN_FAIL;
1338     }
1339
1340     return EXT_RETURN_SENT;
1341 }
1342
1343 EXT_RETURN tls_construct_stoc_early_data(SSL *s, WPACKET *pkt,
1344                                          unsigned int context, X509 *x,
1345                                          size_t chainidx)
1346 {
1347     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
1348         if (s->max_early_data == 0)
1349             return EXT_RETURN_NOT_SENT;
1350
1351         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
1352                 || !WPACKET_start_sub_packet_u16(pkt)
1353                 || !WPACKET_put_bytes_u32(pkt, s->max_early_data)
1354                 || !WPACKET_close(pkt)) {
1355             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1356                      SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA, ERR_R_INTERNAL_ERROR);
1357             return EXT_RETURN_FAIL;
1358         }
1359
1360         return EXT_RETURN_SENT;
1361     }
1362
1363     if (s->ext.early_data != SSL_EARLY_DATA_ACCEPTED)
1364         return EXT_RETURN_NOT_SENT;
1365
1366     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
1367             || !WPACKET_start_sub_packet_u16(pkt)
1368             || !WPACKET_close(pkt)) {
1369         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA,
1370                  ERR_R_INTERNAL_ERROR);
1371         return EXT_RETURN_FAIL;
1372     }
1373
1374     return EXT_RETURN_SENT;
1375 }
1376
1377 EXT_RETURN tls_construct_stoc_psk(SSL *s, WPACKET *pkt, unsigned int context,
1378                                   X509 *x, size_t chainidx)
1379 {
1380     if (!s->hit)
1381         return EXT_RETURN_NOT_SENT;
1382
1383     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
1384             || !WPACKET_start_sub_packet_u16(pkt)
1385             || !WPACKET_put_bytes_u16(pkt, s->session->ext.tick_identity)
1386             || !WPACKET_close(pkt)) {
1387         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1388                  SSL_F_TLS_CONSTRUCT_STOC_PSK, ERR_R_INTERNAL_ERROR);
1389         return EXT_RETURN_FAIL;
1390     }
1391
1392     return EXT_RETURN_SENT;
1393 }