Parse the early_data extension
[openssl.git] / ssl / statem / extensions_srvr.c
1 /*
2  * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the OpenSSL license (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <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, int *al)
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         SSLerr(SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
27                SSL_R_RENEGOTIATION_ENCODING_ERR);
28         *al = SSL_AD_ILLEGAL_PARAMETER;
29         return 0;
30     }
31
32     /* Check that the extension matches */
33     if (ilen != s->s3->previous_client_finished_len) {
34         SSLerr(SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
35                SSL_R_RENEGOTIATION_MISMATCH);
36         *al = SSL_AD_HANDSHAKE_FAILURE;
37         return 0;
38     }
39
40     if (memcmp(data, s->s3->previous_client_finished,
41                s->s3->previous_client_finished_len)) {
42         SSLerr(SSL_F_TLS_PARSE_CTOS_RENEGOTIATE,
43                SSL_R_RENEGOTIATION_MISMATCH);
44         *al = SSL_AD_HANDSHAKE_FAILURE;
45         return 0;
46     }
47
48     s->s3->send_connection_binding = 1;
49
50     return 1;
51 }
52
53 /*-
54  * The servername extension is treated as follows:
55  *
56  * - Only the hostname type is supported with a maximum length of 255.
57  * - The servername is rejected if too long or if it contains zeros,
58  *   in which case an fatal alert is generated.
59  * - The servername field is maintained together with the session cache.
60  * - When a session is resumed, the servername call back invoked in order
61  *   to allow the application to position itself to the right context.
62  * - The servername is acknowledged if it is new for a session or when
63  *   it is identical to a previously used for the same session.
64  *   Applications can control the behaviour.  They can at any time
65  *   set a 'desirable' servername for a new SSL object. This can be the
66  *   case for example with HTTPS when a Host: header field is received and
67  *   a renegotiation is requested. In this case, a possible servername
68  *   presented in the new client hello is only acknowledged if it matches
69  *   the value of the Host: field.
70  * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
71  *   if they provide for changing an explicit servername context for the
72  *   session, i.e. when the session has been established with a servername
73  *   extension.
74  * - On session reconnect, the servername extension may be absent.
75  */
76 int tls_parse_ctos_server_name(SSL *s, PACKET *pkt, unsigned int context,
77                                X509 *x, size_t chainidx, int *al)
78 {
79     unsigned int servname_type;
80     PACKET sni, hostname;
81
82     if (!PACKET_as_length_prefixed_2(pkt, &sni)
83         /* ServerNameList must be at least 1 byte long. */
84         || PACKET_remaining(&sni) == 0) {
85         *al = SSL_AD_DECODE_ERROR;
86         return 0;
87     }
88
89     /*
90      * Although the server_name extension was intended to be
91      * extensible to new name types, RFC 4366 defined the
92      * syntax inextensibly and OpenSSL 1.0.x parses it as
93      * such.
94      * RFC 6066 corrected the mistake but adding new name types
95      * is nevertheless no longer feasible, so act as if no other
96      * SNI types can exist, to simplify parsing.
97      *
98      * Also note that the RFC permits only one SNI value per type,
99      * i.e., we can only have a single hostname.
100      */
101     if (!PACKET_get_1(&sni, &servname_type)
102         || servname_type != TLSEXT_NAMETYPE_host_name
103         || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
104         *al = SSL_AD_DECODE_ERROR;
105         return 0;
106     }
107
108     if (!s->hit) {
109         if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
110             *al = TLS1_AD_UNRECOGNIZED_NAME;
111             return 0;
112         }
113
114         if (PACKET_contains_zero_byte(&hostname)) {
115             *al = TLS1_AD_UNRECOGNIZED_NAME;
116             return 0;
117         }
118
119         OPENSSL_free(s->session->ext.hostname);
120         s->session->ext.hostname = NULL;
121         if (!PACKET_strndup(&hostname, &s->session->ext.hostname)) {
122             *al = TLS1_AD_INTERNAL_ERROR;
123             return 0;
124         }
125
126         s->servername_done = 1;
127     } else {
128         /*
129          * TODO(openssl-team): if the SNI doesn't match, we MUST
130          * fall back to a full handshake.
131          */
132         s->servername_done = s->session->ext.hostname
133             && PACKET_equal(&hostname, s->session->ext.hostname,
134                             strlen(s->session->ext.hostname));
135     }
136
137     return 1;
138 }
139
140 #ifndef OPENSSL_NO_SRP
141 int tls_parse_ctos_srp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
142                        size_t chainidx, int *al)
143 {
144     PACKET srp_I;
145
146     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
147             || PACKET_contains_zero_byte(&srp_I)) {
148         *al = SSL_AD_DECODE_ERROR;
149         return 0;
150     }
151
152     /*
153      * TODO(openssl-team): currently, we re-authenticate the user
154      * upon resumption. Instead, we MUST ignore the login.
155      */
156     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
157         *al = TLS1_AD_INTERNAL_ERROR;
158         return 0;
159     }
160
161     return 1;
162 }
163 #endif
164
165 int tls_parse_ctos_early_data(SSL *s, PACKET *pkt, unsigned int context,
166                               X509 *x, size_t chainidx, int *al)
167 {
168     if (PACKET_remaining(pkt) != 0) {
169         *al = SSL_AD_DECODE_ERROR;
170         return 0;
171     }
172
173     s->ext.expect_early_data = 1;
174
175     return 1;
176 }
177
178 #ifndef OPENSSL_NO_EC
179 int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
180                                  X509 *x, size_t chainidx, int *al)
181 {
182     PACKET ec_point_format_list;
183
184     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
185         || PACKET_remaining(&ec_point_format_list) == 0) {
186         *al = SSL_AD_DECODE_ERROR;
187         return 0;
188     }
189
190     if (!s->hit) {
191         if (!PACKET_memdup(&ec_point_format_list,
192                            &s->session->ext.ecpointformats,
193                            &s->session->ext.ecpointformats_len)) {
194             *al = TLS1_AD_INTERNAL_ERROR;
195             return 0;
196         }
197     }
198
199     return 1;
200 }
201 #endif                          /* OPENSSL_NO_EC */
202
203 int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
204                                   X509 *x, size_t chainidx, int *al)
205 {
206     if (s->ext.session_ticket_cb &&
207             !s->ext.session_ticket_cb(s, PACKET_data(pkt),
208                                   PACKET_remaining(pkt),
209                                   s->ext.session_ticket_cb_arg)) {
210         *al = TLS1_AD_INTERNAL_ERROR;
211         return 0;
212     }
213
214     return 1;
215 }
216
217 int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
218                             size_t chainidx, int *al)
219 {
220     PACKET supported_sig_algs;
221
222     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
223             || PACKET_remaining(&supported_sig_algs) == 0) {
224         *al = SSL_AD_DECODE_ERROR;
225         return 0;
226     }
227
228     if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs)) {
229         *al = TLS1_AD_DECODE_ERROR;
230         return 0;
231     }
232
233     return 1;
234 }
235
236 #ifndef OPENSSL_NO_OCSP
237 int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, unsigned int context,
238                                   X509 *x, size_t chainidx, int *al)
239 {
240     PACKET responder_id_list, exts;
241
242     /* Not defined if we get one of these in a client Certificate */
243     if (x != NULL)
244         return 1;
245
246     if (!PACKET_get_1(pkt, (unsigned int *)&s->ext.status_type)) {
247         *al = SSL_AD_DECODE_ERROR;
248         return 0;
249     }
250
251     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
252         /*
253          * We don't know what to do with any other type so ignore it.
254          */
255         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
256         return 1;
257     }
258
259     if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
260         *al = SSL_AD_DECODE_ERROR;
261         return 0;
262     }
263
264     /*
265      * We remove any OCSP_RESPIDs from a previous handshake
266      * to prevent unbounded memory growth - CVE-2016-6304
267      */
268     sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
269     if (PACKET_remaining(&responder_id_list) > 0) {
270         s->ext.ocsp.ids = sk_OCSP_RESPID_new_null();
271         if (s->ext.ocsp.ids == NULL) {
272             *al = SSL_AD_INTERNAL_ERROR;
273             return 0;
274         }
275     } else {
276         s->ext.ocsp.ids = NULL;
277     }
278
279     while (PACKET_remaining(&responder_id_list) > 0) {
280         OCSP_RESPID *id;
281         PACKET responder_id;
282         const unsigned char *id_data;
283
284         if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id)
285                 || PACKET_remaining(&responder_id) == 0) {
286             *al = SSL_AD_DECODE_ERROR;
287             return 0;
288         }
289
290         id_data = PACKET_data(&responder_id);
291         /* TODO(size_t): Convert d2i_* to size_t */
292         id = d2i_OCSP_RESPID(NULL, &id_data,
293                              (int)PACKET_remaining(&responder_id));
294         if (id == NULL) {
295             *al = SSL_AD_DECODE_ERROR;
296             return 0;
297         }
298
299         if (id_data != PACKET_end(&responder_id)) {
300             OCSP_RESPID_free(id);
301             *al = SSL_AD_DECODE_ERROR;
302             return 0;
303         }
304
305         if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) {
306             OCSP_RESPID_free(id);
307             *al = SSL_AD_INTERNAL_ERROR;
308             return 0;
309         }
310     }
311
312     /* Read in request_extensions */
313     if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
314         *al = SSL_AD_DECODE_ERROR;
315         return 0;
316     }
317
318     if (PACKET_remaining(&exts) > 0) {
319         const unsigned char *ext_data = PACKET_data(&exts);
320
321         sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts,
322                                    X509_EXTENSION_free);
323         s->ext.ocsp.exts =
324             d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
325         if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) {
326             *al = SSL_AD_DECODE_ERROR;
327             return 0;
328         }
329     }
330
331     return 1;
332 }
333 #endif
334
335 #ifndef OPENSSL_NO_NEXTPROTONEG
336 int tls_parse_ctos_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
337                        size_t chainidx, int *al)
338 {
339     /*
340      * We shouldn't accept this extension on a
341      * renegotiation.
342      */
343     if (SSL_IS_FIRST_HANDSHAKE(s))
344         s->s3->npn_seen = 1;
345
346     return 1;
347 }
348 #endif
349
350 /*
351  * Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN
352  * extension, not including type and length. |al| is a pointer to the alert
353  * value to send in the event of a failure. Returns: 1 on success, 0 on error.
354  */
355 int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
356                         size_t chainidx, int *al)
357 {
358     PACKET protocol_list, save_protocol_list, protocol;
359
360     if (!SSL_IS_FIRST_HANDSHAKE(s))
361         return 1;
362
363     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
364         || PACKET_remaining(&protocol_list) < 2) {
365         *al = SSL_AD_DECODE_ERROR;
366         return 0;
367     }
368
369     save_protocol_list = protocol_list;
370     do {
371         /* Protocol names can't be empty. */
372         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
373                 || PACKET_remaining(&protocol) == 0) {
374             *al = SSL_AD_DECODE_ERROR;
375             return 0;
376         }
377     } while (PACKET_remaining(&protocol_list) != 0);
378
379     OPENSSL_free(s->s3->alpn_proposed);
380     s->s3->alpn_proposed = NULL;
381     s->s3->alpn_proposed_len = 0;
382     if (!PACKET_memdup(&save_protocol_list,
383                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
384         *al = TLS1_AD_INTERNAL_ERROR;
385         return 0;
386     }
387
388     return 1;
389 }
390
391 #ifndef OPENSSL_NO_SRTP
392 int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
393                             size_t chainidx, int *al)
394 {
395     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
396     unsigned int ct, mki_len, id;
397     int i, srtp_pref;
398     PACKET subpkt;
399
400     /* Ignore this if we have no SRTP profiles */
401     if (SSL_get_srtp_profiles(s) == NULL)
402         return 1;
403
404     /* Pull off the length of the cipher suite list  and check it is even */
405     if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0
406             || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
407         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
408                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
409         *al = SSL_AD_DECODE_ERROR;
410         return 0;
411     }
412
413     srvr = SSL_get_srtp_profiles(s);
414     s->srtp_profile = NULL;
415     /* Search all profiles for a match initially */
416     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
417
418     while (PACKET_remaining(&subpkt)) {
419         if (!PACKET_get_net_2(&subpkt, &id)) {
420             SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
421                    SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
422             *al = SSL_AD_DECODE_ERROR;
423             return 0;
424         }
425
426         /*
427          * Only look for match in profiles of higher preference than
428          * current match.
429          * If no profiles have been have been configured then this
430          * does nothing.
431          */
432         for (i = 0; i < srtp_pref; i++) {
433             SRTP_PROTECTION_PROFILE *sprof =
434                 sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
435
436             if (sprof->id == id) {
437                 s->srtp_profile = sprof;
438                 srtp_pref = i;
439                 break;
440             }
441         }
442     }
443
444     /* Now extract the MKI value as a sanity check, but discard it for now */
445     if (!PACKET_get_1(pkt, &mki_len)) {
446         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
447                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
448         *al = SSL_AD_DECODE_ERROR;
449         return 0;
450     }
451
452     if (!PACKET_forward(pkt, mki_len)
453         || PACKET_remaining(pkt)) {
454         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
455         *al = SSL_AD_DECODE_ERROR;
456         return 0;
457     }
458
459     return 1;
460 }
461 #endif
462
463 int tls_parse_ctos_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
464                        size_t chainidx, int *al)
465 {
466     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
467         s->ext.use_etm = 1;
468
469     return 1;
470 }
471
472 /*
473  * Process a psk_kex_modes extension received in the ClientHello. |pkt| contains
474  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
475  * If a failure occurs then |*al| is set to an appropriate alert value.
476  */
477 int tls_parse_ctos_psk_kex_modes(SSL *s, PACKET *pkt, unsigned int context,
478                                  X509 *x, size_t chainidx, int *al)
479 {
480 #ifndef OPENSSL_NO_TLS1_3
481     PACKET psk_kex_modes;
482     unsigned int mode;
483
484     if (!PACKET_as_length_prefixed_1(pkt, &psk_kex_modes)
485             || PACKET_remaining(&psk_kex_modes) == 0) {
486         *al = SSL_AD_DECODE_ERROR;
487         return 0;
488     }
489
490     while (PACKET_get_1(&psk_kex_modes, &mode)) {
491         if (mode == TLSEXT_KEX_MODE_KE_DHE)
492             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE_DHE;
493         else if (mode == TLSEXT_KEX_MODE_KE)
494             s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
495     }
496 #endif
497
498     return 1;
499 }
500
501 /*
502  * Process a key_share extension received in the ClientHello. |pkt| contains
503  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
504  * If a failure occurs then |*al| is set to an appropriate alert value.
505  */
506 int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
507                              size_t chainidx, int *al)
508 {
509 #ifndef OPENSSL_NO_TLS1_3
510     unsigned int group_id;
511     PACKET key_share_list, encoded_pt;
512     const unsigned char *clntcurves, *srvrcurves;
513     size_t clnt_num_curves, srvr_num_curves;
514     int group_nid, found = 0;
515     unsigned int curve_flags;
516
517     if (s->hit && (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE_DHE) == 0)
518         return 1;
519
520     /* Sanity check */
521     if (s->s3->peer_tmp != NULL) {
522         *al = SSL_AD_INTERNAL_ERROR;
523         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
524         return 0;
525     }
526
527     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
528         *al = SSL_AD_HANDSHAKE_FAILURE;
529         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
530         return 0;
531     }
532
533     /* Get our list of supported curves */
534     if (!tls1_get_curvelist(s, 0, &srvrcurves, &srvr_num_curves)) {
535         *al = SSL_AD_INTERNAL_ERROR;
536         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
537         return 0;
538     }
539
540     /*
541      * Get the clients list of supported curves.
542      * TODO(TLS1.3): We should validate that we actually received
543      * supported_groups!
544      */
545     if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
546         *al = SSL_AD_INTERNAL_ERROR;
547         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
548         return 0;
549     }
550
551     while (PACKET_remaining(&key_share_list) > 0) {
552         if (!PACKET_get_net_2(&key_share_list, &group_id)
553                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
554                 || PACKET_remaining(&encoded_pt) == 0) {
555             *al = SSL_AD_HANDSHAKE_FAILURE;
556             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
557                    SSL_R_LENGTH_MISMATCH);
558             return 0;
559         }
560
561         /*
562          * If we already found a suitable key_share we loop through the
563          * rest to verify the structure, but don't process them.
564          */
565         if (found)
566             continue;
567
568         /* Check if this share is in supported_groups sent from client */
569         if (!check_in_list(s, group_id, clntcurves, clnt_num_curves, 0)) {
570             *al = SSL_AD_HANDSHAKE_FAILURE;
571             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
572             return 0;
573         }
574
575         /* Check if this share is for a group we can use */
576         if (!check_in_list(s, group_id, srvrcurves, srvr_num_curves, 1)) {
577             /* Share not suitable */
578             continue;
579         }
580
581         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
582
583         if (group_nid == 0) {
584             *al = SSL_AD_INTERNAL_ERROR;
585             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
586                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
587             return 0;
588         }
589
590         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
591             /* Can happen for some curves, e.g. X25519 */
592             EVP_PKEY *key = EVP_PKEY_new();
593
594             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
595                 *al = SSL_AD_INTERNAL_ERROR;
596                 SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_EVP_LIB);
597                 EVP_PKEY_free(key);
598                 return 0;
599             }
600             s->s3->peer_tmp = key;
601         } else {
602             /* Set up EVP_PKEY with named curve as parameters */
603             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
604
605             if (pctx == NULL
606                     || EVP_PKEY_paramgen_init(pctx) <= 0
607                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
608                                                               group_nid) <= 0
609                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
610                 *al = SSL_AD_INTERNAL_ERROR;
611                 SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_EVP_LIB);
612                 EVP_PKEY_CTX_free(pctx);
613                 return 0;
614             }
615             EVP_PKEY_CTX_free(pctx);
616             pctx = NULL;
617         }
618         s->s3->group_id = group_id;
619
620         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
621                 PACKET_data(&encoded_pt),
622                 PACKET_remaining(&encoded_pt))) {
623             *al = SSL_AD_DECODE_ERROR;
624             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_ECPOINT);
625             return 0;
626         }
627
628         found = 1;
629     }
630 #endif
631
632     return 1;
633 }
634
635 #ifndef OPENSSL_NO_EC
636 int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, unsigned int context,
637                                     X509 *x, size_t chainidx, int *al)
638 {
639     PACKET supported_groups_list;
640
641     /* Each group is 2 bytes and we must have at least 1. */
642     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
643             || PACKET_remaining(&supported_groups_list) == 0
644             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
645         *al = SSL_AD_DECODE_ERROR;
646         return 0;
647     }
648
649     OPENSSL_free(s->session->ext.supportedgroups);
650     s->session->ext.supportedgroups = NULL;
651     s->session->ext.supportedgroups_len = 0;
652     if (!PACKET_memdup(&supported_groups_list,
653                        &s->session->ext.supportedgroups,
654                        &s->session->ext.supportedgroups_len)) {
655         *al = SSL_AD_DECODE_ERROR;
656         return 0;
657     }
658
659     return 1;
660 }
661 #endif
662
663 int tls_parse_ctos_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
664                        size_t chainidx, int *al)
665 {
666     /* The extension must always be empty */
667     if (PACKET_remaining(pkt) != 0) {
668         *al = SSL_AD_DECODE_ERROR;
669         return 0;
670     }
671
672     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
673
674     return 1;
675 }
676
677 int tls_parse_ctos_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
678                        size_t chainidx, int *al)
679 {
680     PACKET identities, binders, binder;
681     size_t binderoffset, hashsize;
682     SSL_SESSION *sess = NULL;
683     unsigned int id, i;
684     const EVP_MD *md = NULL;
685
686     /*
687      * If we have no PSK kex mode that we recognise then we can't resume so
688      * ignore this extension
689      */
690     if ((s->ext.psk_kex_mode
691             & (TLSEXT_KEX_MODE_FLAG_KE | TLSEXT_KEX_MODE_FLAG_KE_DHE)) == 0)
692         return 1;
693
694     if (!PACKET_get_length_prefixed_2(pkt, &identities)) {
695         *al = SSL_AD_DECODE_ERROR;
696         return 0;
697     }
698
699     for (id = 0; PACKET_remaining(&identities) != 0; id++) {
700         PACKET identity;
701         unsigned long ticket_age;
702         int ret;
703
704         if (!PACKET_get_length_prefixed_2(&identities, &identity)
705                 || !PACKET_get_net_4(&identities, &ticket_age)) {
706             *al = SSL_AD_DECODE_ERROR;
707             return 0;
708         }
709
710         /* TODO(TLS1.3): Should we validate the ticket age? */
711
712         ret = tls_decrypt_ticket(s, PACKET_data(&identity),
713                                  PACKET_remaining(&identity), NULL, 0, &sess);
714         if (ret == TICKET_FATAL_ERR_MALLOC || ret == TICKET_FATAL_ERR_OTHER) {
715             *al = SSL_AD_INTERNAL_ERROR;
716             return 0;
717         }
718         if (ret == TICKET_NO_DECRYPT)
719             continue;
720
721         md = ssl_md(sess->cipher->algorithm2);
722         if (md == NULL) {
723             /*
724              * Don't recognise this cipher so we can't use the session.
725              * Ignore it
726              */
727             SSL_SESSION_free(sess);
728             sess = NULL;
729             continue;
730         }
731
732         /*
733          * TODO(TLS1.3): Somehow we need to handle the case of a ticket renewal.
734          * Ignored for now
735          */
736
737         break;
738     }
739
740     if (sess == NULL)
741         return 1;
742
743     binderoffset = PACKET_data(pkt) - (const unsigned char *)s->init_buf->data;
744     hashsize = EVP_MD_size(md);
745
746     if (!PACKET_get_length_prefixed_2(pkt, &binders)) {
747         *al = SSL_AD_DECODE_ERROR;
748         goto err;
749     }
750
751     for (i = 0; i <= id; i++) {
752         if (!PACKET_get_length_prefixed_1(&binders, &binder)) {
753             *al = SSL_AD_DECODE_ERROR;
754             goto err;
755         }
756     }
757
758     if (PACKET_remaining(&binder) != hashsize
759             || tls_psk_do_binder(s, md,
760                                  (const unsigned char *)s->init_buf->data,
761                                  binderoffset, PACKET_data(&binder), NULL,
762                                  sess, 0) != 1) {
763         *al = SSL_AD_DECODE_ERROR;
764         SSLerr(SSL_F_TLS_PARSE_CTOS_PSK, ERR_R_INTERNAL_ERROR);
765         goto err;
766     }
767
768     sess->ext.tick_identity = id;
769     SSL_SESSION_free(s->session);
770     s->session = sess;
771     return 1;
772 err:
773     return 0;
774 }
775
776 /*
777  * Add the server's renegotiation binding
778  */
779 int tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt, unsigned int context,
780                                    X509 *x, size_t chainidx, int *al)
781 {
782     if (!s->s3->send_connection_binding)
783         return 1;
784
785     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
786             || !WPACKET_start_sub_packet_u16(pkt)
787             || !WPACKET_start_sub_packet_u8(pkt)
788             || !WPACKET_memcpy(pkt, s->s3->previous_client_finished,
789                                s->s3->previous_client_finished_len)
790             || !WPACKET_memcpy(pkt, s->s3->previous_server_finished,
791                                s->s3->previous_server_finished_len)
792             || !WPACKET_close(pkt)
793             || !WPACKET_close(pkt)) {
794         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
795         return 0;
796     }
797
798     return 1;
799 }
800
801 int tls_construct_stoc_server_name(SSL *s, WPACKET *pkt, unsigned int context,
802                                    X509 *x, size_t chainidx, int *al)
803 {
804     if (s->hit || s->servername_done != 1
805             || s->session->ext.hostname == NULL)
806         return 1;
807
808     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
809             || !WPACKET_put_bytes_u16(pkt, 0)) {
810         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME, ERR_R_INTERNAL_ERROR);
811         return 0;
812     }
813
814     return 1;
815 }
816
817 int tls_construct_stoc_early_data_info(SSL *s, WPACKET *pkt,
818                                        unsigned int context, X509 *x,
819                                        size_t chainidx, int *al)
820 {
821     if (s->max_early_data == 0)
822         return 1;
823
824     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data_info)
825             || !WPACKET_start_sub_packet_u16(pkt)
826             || !WPACKET_put_bytes_u32(pkt, s->max_early_data)
827             || !WPACKET_close(pkt)) {
828         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_EARLY_DATA_INFO, ERR_R_INTERNAL_ERROR);
829         return 0;
830     }
831
832     return 1;
833 }
834
835 #ifndef OPENSSL_NO_EC
836 int tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt, unsigned int context,
837                                      X509 *x, size_t chainidx, int *al)
838 {
839     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
840     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
841     int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
842                     && (s->session->ext.ecpointformats != NULL);
843     const unsigned char *plist;
844     size_t plistlen;
845
846     if (!using_ecc)
847         return 1;
848
849     tls1_get_formatlist(s, &plist, &plistlen);
850     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
851             || !WPACKET_start_sub_packet_u16(pkt)
852             || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
853             || !WPACKET_close(pkt)) {
854         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
855         return 0;
856     }
857
858     return 1;
859 }
860 #endif
861
862 int tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt,
863                                       unsigned int context, X509 *x,
864                                       size_t chainidx, int *al)
865 {
866     if (!s->ext.ticket_expected || !tls_use_ticket(s)) {
867         s->ext.ticket_expected = 0;
868         return 1;
869     }
870
871     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
872             || !WPACKET_put_bytes_u16(pkt, 0)) {
873         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
874         return 0;
875     }
876
877     return 1;
878 }
879
880 #ifndef OPENSSL_NO_OCSP
881 int tls_construct_stoc_status_request(SSL *s, WPACKET *pkt,
882                                       unsigned int context, X509 *x,
883                                       size_t chainidx, int *al)
884 {
885     if (!s->ext.status_expected)
886         return 1;
887
888     if (SSL_IS_TLS13(s) && chainidx != 0)
889         return 1;
890
891     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
892             || !WPACKET_start_sub_packet_u16(pkt)) {
893         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
894         return 0;
895     }
896
897     /*
898      * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we
899      * send back an empty extension, with the certificate status appearing as a
900      * separate message
901      */
902     if ((SSL_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt))
903             || !WPACKET_close(pkt)) {
904         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
905         return 0;
906     }
907
908     return 1;
909 }
910 #endif
911
912 #ifndef OPENSSL_NO_NEXTPROTONEG
913 int tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt,
914                                       unsigned int context, X509 *x,
915                                       size_t chainidx, int *al)
916 {
917     const unsigned char *npa;
918     unsigned int npalen;
919     int ret;
920     int npn_seen = s->s3->npn_seen;
921
922     s->s3->npn_seen = 0;
923     if (!npn_seen || s->ctx->ext.npn_advertised_cb == NULL)
924         return 1;
925
926     ret = s->ctx->ext.npn_advertised_cb(s, &npa, &npalen,
927                                         s->ctx->ext.npn_advertised_cb_arg);
928     if (ret == SSL_TLSEXT_ERR_OK) {
929         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
930                 || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
931             SSLerr(SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG,
932                    ERR_R_INTERNAL_ERROR);
933             return 0;
934         }
935         s->s3->npn_seen = 1;
936     }
937
938     return 1;
939 }
940 #endif
941
942 int tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, unsigned int context, X509 *x,
943                             size_t chainidx, int *al)
944 {
945     if (s->s3->alpn_selected == NULL)
946         return 1;
947
948     if (!WPACKET_put_bytes_u16(pkt,
949                 TLSEXT_TYPE_application_layer_protocol_negotiation)
950             || !WPACKET_start_sub_packet_u16(pkt)
951             || !WPACKET_start_sub_packet_u16(pkt)
952             || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
953                                       s->s3->alpn_selected_len)
954             || !WPACKET_close(pkt)
955             || !WPACKET_close(pkt)) {
956         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_ALPN, ERR_R_INTERNAL_ERROR);
957         return 0;
958     }
959
960     return 1;
961 }
962
963 #ifndef OPENSSL_NO_SRTP
964 int tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt, unsigned int context,
965                                 X509 *x, size_t chainidx, int *al)
966 {
967     if (s->srtp_profile == NULL)
968         return 1;
969
970     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
971             || !WPACKET_start_sub_packet_u16(pkt)
972             || !WPACKET_put_bytes_u16(pkt, 2)
973             || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
974             || !WPACKET_put_bytes_u8(pkt, 0)
975             || !WPACKET_close(pkt)) {
976         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP, ERR_R_INTERNAL_ERROR);
977         return 0;
978     }
979
980     return 1;
981 }
982 #endif
983
984 int tls_construct_stoc_etm(SSL *s, WPACKET *pkt, unsigned int context, X509 *x,
985                            size_t chainidx, int *al)
986 {
987     if (!s->ext.use_etm)
988         return 1;
989
990     /*
991      * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
992      * for other cases too.
993      */
994     if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
995         || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
996         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
997         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12) {
998         s->ext.use_etm = 0;
999         return 1;
1000     }
1001
1002     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
1003             || !WPACKET_put_bytes_u16(pkt, 0)) {
1004         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_ETM, ERR_R_INTERNAL_ERROR);
1005         return 0;
1006     }
1007
1008     return 1;
1009 }
1010
1011 int tls_construct_stoc_ems(SSL *s, WPACKET *pkt, unsigned int context, X509 *x,
1012                            size_t chainidx, int *al)
1013 {
1014     if ((s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
1015         return 1;
1016
1017     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
1018             || !WPACKET_put_bytes_u16(pkt, 0)) {
1019         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_EMS, ERR_R_INTERNAL_ERROR);
1020         return 0;
1021     }
1022
1023     return 1;
1024 }
1025
1026 int tls_construct_stoc_key_share(SSL *s, WPACKET *pkt, unsigned int context,
1027                                  X509 *x, size_t chainidx, int *al)
1028 {
1029 #ifndef OPENSSL_NO_TLS1_3
1030     unsigned char *encodedPoint;
1031     size_t encoded_pt_len = 0;
1032     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
1033
1034     if (ckey == NULL) {
1035         /* No key_share received from client */
1036         if (s->hello_retry_request) {
1037             if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1038                     || !WPACKET_start_sub_packet_u16(pkt)
1039                     || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)
1040                     || !WPACKET_close(pkt)) {
1041                 SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE,
1042                        ERR_R_INTERNAL_ERROR);
1043                 return 0;
1044             }
1045
1046             return 1;
1047         }
1048
1049         /* Must be resuming. */
1050         if (!s->hit || !tls13_generate_handshake_secret(s, NULL, 0)) {
1051             *al = SSL_AD_INTERNAL_ERROR;
1052             SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1053             return 0;
1054         }
1055         return 1;
1056     }
1057
1058     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
1059             || !WPACKET_start_sub_packet_u16(pkt)
1060             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
1061         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1062         return 0;
1063     }
1064
1065     skey = ssl_generate_pkey(ckey);
1066     if (skey == NULL) {
1067         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_MALLOC_FAILURE);
1068         return 0;
1069     }
1070
1071     /* Generate encoding of server key */
1072     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
1073     if (encoded_pt_len == 0) {
1074         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_EC_LIB);
1075         EVP_PKEY_free(skey);
1076         return 0;
1077     }
1078
1079     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
1080             || !WPACKET_close(pkt)) {
1081         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1082         EVP_PKEY_free(skey);
1083         OPENSSL_free(encodedPoint);
1084         return 0;
1085     }
1086     OPENSSL_free(encodedPoint);
1087
1088     /* This causes the crypto state to be updated based on the derived keys */
1089     s->s3->tmp.pkey = skey;
1090     if (ssl_derive(s, skey, ckey, 1) == 0) {
1091         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1092         return 0;
1093     }
1094 #endif
1095
1096     return 1;
1097 }
1098
1099 int tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt, unsigned int context,
1100                                      X509 *x, size_t chainidx, int *al)
1101 {
1102     const unsigned char cryptopro_ext[36] = {
1103         0xfd, 0xe8,         /* 65000 */
1104         0x00, 0x20,         /* 32 bytes length */
1105         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1106         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1107         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1108         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1109     };
1110
1111     if (((s->s3->tmp.new_cipher->id & 0xFFFF) != 0x80
1112          && (s->s3->tmp.new_cipher->id & 0xFFFF) != 0x81)
1113             || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
1114         return 1;
1115
1116     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1117         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG, ERR_R_INTERNAL_ERROR);
1118         return 0;
1119     }
1120
1121     return 1;
1122 }
1123
1124 int tls_construct_stoc_psk(SSL *s, WPACKET *pkt, unsigned int context, X509 *x,
1125                            size_t chainidx, int *al)
1126 {
1127     if (!s->hit)
1128         return 1;
1129
1130     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
1131             || !WPACKET_start_sub_packet_u16(pkt)
1132             || !WPACKET_put_bytes_u16(pkt, s->session->ext.tick_identity)
1133             || !WPACKET_close(pkt)) {
1134         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_PSK, ERR_R_INTERNAL_ERROR);
1135         return 0;
1136     }
1137
1138     return 1;
1139 }