Remove use of the SSL3_FLAGS_NO_RENEGOTIATE_CIPHERS flag
[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, X509 *x, size_t chainidx,
18                                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, X509 *x, size_t chainidx,
77                                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         if (!PACKET_strndup(&hostname, &s->session->ext.hostname)) {
120             *al = TLS1_AD_INTERNAL_ERROR;
121             return 0;
122         }
123
124         s->servername_done = 1;
125     } else {
126         /*
127          * TODO(openssl-team): if the SNI doesn't match, we MUST
128          * fall back to a full handshake.
129          */
130         s->servername_done = s->session->ext.hostname
131             && PACKET_equal(&hostname, s->session->ext.hostname,
132                             strlen(s->session->ext.hostname));
133     }
134
135     return 1;
136 }
137
138 #ifndef OPENSSL_NO_SRP
139 int tls_parse_ctos_srp(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al)
140 {
141     PACKET srp_I;
142
143     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
144             || PACKET_contains_zero_byte(&srp_I)) {
145         *al = SSL_AD_DECODE_ERROR;
146         return 0;
147     }
148
149     /*
150      * TODO(openssl-team): currently, we re-authenticate the user
151      * upon resumption. Instead, we MUST ignore the login.
152      */
153     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
154         *al = TLS1_AD_INTERNAL_ERROR;
155         return 0;
156     }
157
158     return 1;
159 }
160 #endif
161
162 #ifndef OPENSSL_NO_EC
163 int tls_parse_ctos_ec_pt_formats(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
164                                  int *al)
165 {
166     PACKET ec_point_format_list;
167
168     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
169         || PACKET_remaining(&ec_point_format_list) == 0) {
170         *al = SSL_AD_DECODE_ERROR;
171         return 0;
172     }
173
174     if (!s->hit) {
175         if (!PACKET_memdup(&ec_point_format_list,
176                            &s->session->ext.ecpointformats,
177                            &s->session->ext.ecpointformats_len)) {
178             *al = TLS1_AD_INTERNAL_ERROR;
179             return 0;
180         }
181     }
182
183     return 1;
184 }
185 #endif                          /* OPENSSL_NO_EC */
186
187 int tls_parse_ctos_session_ticket(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
188                                   int *al)
189 {
190     if (s->ext.session_ticket_cb &&
191             !s->ext.session_ticket_cb(s, PACKET_data(pkt),
192                                   PACKET_remaining(pkt),
193                                   s->ext.session_ticket_cb_arg)) {
194         *al = TLS1_AD_INTERNAL_ERROR;
195         return 0;
196     }
197
198     return 1;
199 }
200
201 int tls_parse_ctos_sig_algs(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
202                             int *al)
203 {
204     PACKET supported_sig_algs;
205
206     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
207             || PACKET_remaining(&supported_sig_algs) == 0) {
208         *al = SSL_AD_DECODE_ERROR;
209         return 0;
210     }
211
212     if (!s->hit && !tls1_save_sigalgs(s, &supported_sig_algs)) {
213         *al = TLS1_AD_DECODE_ERROR;
214         return 0;
215     }
216
217     return 1;
218 }
219
220 #ifndef OPENSSL_NO_OCSP
221 int tls_parse_ctos_status_request(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
222                                   int *al)
223 {
224     PACKET responder_id_list, exts;
225
226     /* Not defined if we get one of these in a client Certificate */
227     if (x != NULL)
228         return 1;
229
230     if (!PACKET_get_1(pkt, (unsigned int *)&s->ext.status_type)) {
231         *al = SSL_AD_DECODE_ERROR;
232         return 0;
233     }
234
235     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
236         /*
237          * We don't know what to do with any other type so ignore it.
238          */
239         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
240         return 1;
241     }
242
243     if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
244         *al = SSL_AD_DECODE_ERROR;
245         return 0;
246     }
247
248     /*
249      * We remove any OCSP_RESPIDs from a previous handshake
250      * to prevent unbounded memory growth - CVE-2016-6304
251      */
252     sk_OCSP_RESPID_pop_free(s->ext.ocsp.ids, OCSP_RESPID_free);
253     if (PACKET_remaining(&responder_id_list) > 0) {
254         s->ext.ocsp.ids = sk_OCSP_RESPID_new_null();
255         if (s->ext.ocsp.ids == NULL) {
256             *al = SSL_AD_INTERNAL_ERROR;
257             return 0;
258         }
259     } else {
260         s->ext.ocsp.ids = NULL;
261     }
262
263     while (PACKET_remaining(&responder_id_list) > 0) {
264         OCSP_RESPID *id;
265         PACKET responder_id;
266         const unsigned char *id_data;
267
268         if (!PACKET_get_length_prefixed_2(&responder_id_list, &responder_id)
269                 || PACKET_remaining(&responder_id) == 0) {
270             *al = SSL_AD_DECODE_ERROR;
271             return 0;
272         }
273
274         id_data = PACKET_data(&responder_id);
275         /* TODO(size_t): Convert d2i_* to size_t */
276         id = d2i_OCSP_RESPID(NULL, &id_data,
277                              (int)PACKET_remaining(&responder_id));
278         if (id == NULL) {
279             *al = SSL_AD_DECODE_ERROR;
280             return 0;
281         }
282
283         if (id_data != PACKET_end(&responder_id)) {
284             OCSP_RESPID_free(id);
285             *al = SSL_AD_DECODE_ERROR;
286             return 0;
287         }
288
289         if (!sk_OCSP_RESPID_push(s->ext.ocsp.ids, id)) {
290             OCSP_RESPID_free(id);
291             *al = SSL_AD_INTERNAL_ERROR;
292             return 0;
293         }
294     }
295
296     /* Read in request_extensions */
297     if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
298         *al = SSL_AD_DECODE_ERROR;
299         return 0;
300     }
301
302     if (PACKET_remaining(&exts) > 0) {
303         const unsigned char *ext_data = PACKET_data(&exts);
304
305         sk_X509_EXTENSION_pop_free(s->ext.ocsp.exts,
306                                    X509_EXTENSION_free);
307         s->ext.ocsp.exts =
308             d2i_X509_EXTENSIONS(NULL, &ext_data, (int)PACKET_remaining(&exts));
309         if (s->ext.ocsp.exts == NULL || ext_data != PACKET_end(&exts)) {
310             *al = SSL_AD_DECODE_ERROR;
311             return 0;
312         }
313     }
314
315     return 1;
316 }
317 #endif
318
319 #ifndef OPENSSL_NO_NEXTPROTONEG
320 int tls_parse_ctos_npn(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al)
321 {
322     /*
323      * We shouldn't accept this extension on a
324      * renegotiation.
325      *
326      * s->new_session will be set on renegotiation, but we
327      * probably shouldn't rely that it couldn't be set on
328      * the initial renegotiation too in certain cases (when
329      * there's some other reason to disallow resuming an
330      * earlier session -- the current code won't be doing
331      * anything like that, but this might change).
332      *
333      * A valid sign that there's been a previous handshake
334      * in this connection is if s->s3->tmp.finish_md_len >
335      * 0.  (We are talking about a check that will happen
336      * in the Hello protocol round, well before a new
337      * Finished message could have been computed.)
338      */
339     if (s->s3->tmp.finish_md_len == 0)
340         s->s3->npn_seen = 1;
341
342     return 1;
343 }
344 #endif
345
346 /*
347  * Save the ALPN extension in a ClientHello.|pkt| holds the contents of the ALPN
348  * extension, not including type and length. |al| is a pointer to the alert
349  * value to send in the event of a failure. Returns: 1 on success, 0 on error.
350  */
351 int tls_parse_ctos_alpn(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al)
352 {
353     PACKET protocol_list, save_protocol_list, protocol;
354
355     if (s->s3->tmp.finish_md_len != 0)
356         return 1;
357
358     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
359         || PACKET_remaining(&protocol_list) < 2) {
360         *al = SSL_AD_DECODE_ERROR;
361         return 0;
362     }
363
364     save_protocol_list = protocol_list;
365     do {
366         /* Protocol names can't be empty. */
367         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
368                 || PACKET_remaining(&protocol) == 0) {
369             *al = SSL_AD_DECODE_ERROR;
370             return 0;
371         }
372     } while (PACKET_remaining(&protocol_list) != 0);
373
374     if (!PACKET_memdup(&save_protocol_list,
375                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
376         *al = TLS1_AD_INTERNAL_ERROR;
377         return 0;
378     }
379
380     return 1;
381 }
382
383 #ifndef OPENSSL_NO_SRTP
384 int tls_parse_ctos_use_srtp(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
385                             int *al)
386 {
387     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
388     unsigned int ct, mki_len, id;
389     int i, srtp_pref;
390     PACKET subpkt;
391
392     /* Ignore this if we have no SRTP profiles */
393     if (SSL_get_srtp_profiles(s) == NULL)
394         return 1;
395
396     /* Pull off the length of the cipher suite list  and check it is even */
397     if (!PACKET_get_net_2(pkt, &ct) || (ct & 1) != 0
398             || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
399         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
400                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
401         *al = SSL_AD_DECODE_ERROR;
402         return 0;
403     }
404
405     srvr = SSL_get_srtp_profiles(s);
406     s->srtp_profile = NULL;
407     /* Search all profiles for a match initially */
408     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
409
410     while (PACKET_remaining(&subpkt)) {
411         if (!PACKET_get_net_2(&subpkt, &id)) {
412             SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
413                    SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
414             *al = SSL_AD_DECODE_ERROR;
415             return 0;
416         }
417
418         /*
419          * Only look for match in profiles of higher preference than
420          * current match.
421          * If no profiles have been have been configured then this
422          * does nothing.
423          */
424         for (i = 0; i < srtp_pref; i++) {
425             SRTP_PROTECTION_PROFILE *sprof =
426                 sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
427
428             if (sprof->id == id) {
429                 s->srtp_profile = sprof;
430                 srtp_pref = i;
431                 break;
432             }
433         }
434     }
435
436     /* Now extract the MKI value as a sanity check, but discard it for now */
437     if (!PACKET_get_1(pkt, &mki_len)) {
438         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP,
439                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
440         *al = SSL_AD_DECODE_ERROR;
441         return 0;
442     }
443
444     if (!PACKET_forward(pkt, mki_len)
445         || PACKET_remaining(pkt)) {
446         SSLerr(SSL_F_TLS_PARSE_CTOS_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
447         *al = SSL_AD_DECODE_ERROR;
448         return 0;
449     }
450
451     return 1;
452 }
453 #endif
454
455 int tls_parse_ctos_etm(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al)
456 {
457     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
458         s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
459
460     return 1;
461 }
462
463 /*
464  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
465  * and |checkallow| is 1 then additionally check if the group is allowed to be
466  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
467  * 1) or 0 otherwise.
468  */
469 #ifndef OPENSSL_NO_TLS1_3
470 static int check_in_list(SSL *s, unsigned int group_id,
471                          const unsigned char *groups, size_t num_groups,
472                          int checkallow)
473 {
474     size_t i;
475
476     if (groups == NULL || num_groups == 0)
477         return 0;
478
479     for (i = 0; i < num_groups; i++, groups += 2) {
480         unsigned int share_id = (groups[0] << 8) | (groups[1]);
481
482         if (group_id == share_id
483                 && (!checkallow
484                     || tls_curve_allowed(s, groups, SSL_SECOP_CURVE_CHECK))) {
485             break;
486         }
487     }
488
489     /* If i == num_groups then not in the list */
490     return i < num_groups;
491 }
492 #endif
493
494 /*
495  * Process a key_share extension received in the ClientHello. |pkt| contains
496  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
497  * If a failure occurs then |*al| is set to an appropriate alert value.
498  */
499 int tls_parse_ctos_key_share(SSL *s, PACKET *pkt, X509 *x, size_t chainidx,
500                              int *al)
501 {
502 #ifndef OPENSSL_NO_TLS1_3
503     unsigned int group_id;
504     PACKET key_share_list, encoded_pt;
505     const unsigned char *clntcurves, *srvrcurves;
506     size_t clnt_num_curves, srvr_num_curves;
507     int group_nid, found = 0;
508     unsigned int curve_flags;
509
510     if (s->hit)
511         return 1;
512
513     /* Sanity check */
514     if (s->s3->peer_tmp != NULL) {
515         *al = SSL_AD_INTERNAL_ERROR;
516         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
517         return 0;
518     }
519
520     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
521         *al = SSL_AD_HANDSHAKE_FAILURE;
522         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
523         return 0;
524     }
525
526     /* Get our list of supported curves */
527     if (!tls1_get_curvelist(s, 0, &srvrcurves, &srvr_num_curves)) {
528         *al = SSL_AD_INTERNAL_ERROR;
529         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
530         return 0;
531     }
532
533     /*
534      * Get the clients list of supported curves.
535      * TODO(TLS1.3): We should validate that we actually received
536      * supported_groups!
537      */
538     if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
539         *al = SSL_AD_INTERNAL_ERROR;
540         SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_INTERNAL_ERROR);
541         return 0;
542     }
543
544     while (PACKET_remaining(&key_share_list) > 0) {
545         if (!PACKET_get_net_2(&key_share_list, &group_id)
546                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
547                 || PACKET_remaining(&encoded_pt) == 0) {
548             *al = SSL_AD_HANDSHAKE_FAILURE;
549             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
550                    SSL_R_LENGTH_MISMATCH);
551             return 0;
552         }
553
554         /*
555          * If we already found a suitable key_share we loop through the
556          * rest to verify the structure, but don't process them.
557          */
558         if (found)
559             continue;
560
561         /* Check if this share is in supported_groups sent from client */
562         if (!check_in_list(s, group_id, clntcurves, clnt_num_curves, 0)) {
563             *al = SSL_AD_HANDSHAKE_FAILURE;
564             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
565             return 0;
566         }
567
568         /* Check if this share is for a group we can use */
569         if (!check_in_list(s, group_id, srvrcurves, srvr_num_curves, 1)) {
570             /* Share not suitable */
571             continue;
572         }
573
574         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
575
576         if (group_nid == 0) {
577             *al = SSL_AD_INTERNAL_ERROR;
578             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE,
579                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
580             return 0;
581         }
582
583         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
584             /* Can happen for some curves, e.g. X25519 */
585             EVP_PKEY *key = EVP_PKEY_new();
586
587             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
588                 *al = SSL_AD_INTERNAL_ERROR;
589                 SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_EVP_LIB);
590                 EVP_PKEY_free(key);
591                 return 0;
592             }
593             s->s3->peer_tmp = key;
594         } else {
595             /* Set up EVP_PKEY with named curve as parameters */
596             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
597
598             if (pctx == NULL
599                     || EVP_PKEY_paramgen_init(pctx) <= 0
600                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
601                                                               group_nid) <= 0
602                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
603                 *al = SSL_AD_INTERNAL_ERROR;
604                 SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, ERR_R_EVP_LIB);
605                 EVP_PKEY_CTX_free(pctx);
606                 return 0;
607             }
608             EVP_PKEY_CTX_free(pctx);
609             pctx = NULL;
610         }
611         s->s3->group_id = group_id;
612
613         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
614                 PACKET_data(&encoded_pt),
615                 PACKET_remaining(&encoded_pt))) {
616             *al = SSL_AD_DECODE_ERROR;
617             SSLerr(SSL_F_TLS_PARSE_CTOS_KEY_SHARE, SSL_R_BAD_ECPOINT);
618             return 0;
619         }
620
621         found = 1;
622     }
623 #endif
624
625     return 1;
626 }
627
628 #ifndef OPENSSL_NO_EC
629 int tls_parse_ctos_supported_groups(SSL *s, PACKET *pkt, X509 *x,
630                                     size_t chainidx, int *al)
631 {
632     PACKET supported_groups_list;
633
634     /* Each group is 2 bytes and we must have at least 1. */
635     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
636             || PACKET_remaining(&supported_groups_list) == 0
637             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
638         *al = SSL_AD_DECODE_ERROR;
639         return 0;
640     }
641
642     if (!s->hit
643             && !PACKET_memdup(&supported_groups_list,
644                               &s->session->ext.supportedgroups,
645                               &s->session->ext.supportedgroups_len)) {
646         *al = SSL_AD_DECODE_ERROR;
647         return 0;
648     }
649
650     return 1;
651 }
652 #endif
653
654 int tls_parse_ctos_ems(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al)
655 {
656     /* The extension must always be empty */
657     if (PACKET_remaining(pkt) != 0) {
658         *al = SSL_AD_DECODE_ERROR;
659         return 0;
660     }
661
662     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
663
664     return 1;
665 }
666
667 /*
668  * Add the server's renegotiation binding
669  */
670 int tls_construct_stoc_renegotiate(SSL *s, WPACKET *pkt, X509 *x, size_t
671                                    chainidx, int *al)
672 {
673     if (!s->s3->send_connection_binding)
674         return 1;
675
676     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
677             || !WPACKET_start_sub_packet_u16(pkt)
678             || !WPACKET_start_sub_packet_u8(pkt)
679             || !WPACKET_memcpy(pkt, s->s3->previous_client_finished,
680                                s->s3->previous_client_finished_len)
681             || !WPACKET_memcpy(pkt, s->s3->previous_server_finished,
682                                s->s3->previous_server_finished_len)
683             || !WPACKET_close(pkt)
684             || !WPACKET_close(pkt)) {
685         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
686         return 0;
687     }
688
689     return 1;
690 }
691
692 int tls_construct_stoc_server_name(SSL *s, WPACKET *pkt, X509 *x,
693                                    size_t chainidx, int *al)
694 {
695     if (s->hit || s->servername_done != 1
696             || s->session->ext.hostname == NULL)
697         return 1;
698
699     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
700             || !WPACKET_put_bytes_u16(pkt, 0)) {
701         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_SERVER_NAME, ERR_R_INTERNAL_ERROR);
702         return 0;
703     }
704
705     return 1;
706 }
707
708 #ifndef OPENSSL_NO_EC
709 int tls_construct_stoc_ec_pt_formats(SSL *s, WPACKET *pkt, X509 *x,
710                                      size_t chainidx, int *al)
711 {
712     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
713     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
714     int using_ecc = ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))
715                     && (s->session->ext.ecpointformats != NULL);
716     const unsigned char *plist;
717     size_t plistlen;
718
719     if (!using_ecc)
720         return 1;
721
722     tls1_get_formatlist(s, &plist, &plistlen);
723     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
724             || !WPACKET_start_sub_packet_u16(pkt)
725             || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
726             || !WPACKET_close(pkt)) {
727         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
728         return 0;
729     }
730
731     return 1;
732 }
733 #endif
734
735 int tls_construct_stoc_session_ticket(SSL *s, WPACKET *pkt, X509 *x,
736                                       size_t chainidx, int *al)
737 {
738     if (!s->ext.ticket_expected || !tls_use_ticket(s)) {
739         s->ext.ticket_expected = 0;
740         return 1;
741     }
742
743     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
744             || !WPACKET_put_bytes_u16(pkt, 0)) {
745         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
746         return 0;
747     }
748
749     return 1;
750 }
751
752 #ifndef OPENSSL_NO_OCSP
753 int tls_construct_stoc_status_request(SSL *s, WPACKET *pkt, X509 *x,
754                                      size_t chainidx, int *al)
755 {
756     if (!s->ext.status_expected)
757         return 1;
758
759     if (SSL_IS_TLS13(s) && chainidx != 0)
760         return 1;
761
762     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
763             || !WPACKET_start_sub_packet_u16(pkt)) {
764         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
765         return 0;
766     }
767
768     /*
769      * In TLSv1.3 we include the certificate status itself. In <= TLSv1.2 we
770      * send back an empty extension, with the certificate status appearing as a
771      * separate message
772      */
773     if ((SSL_IS_TLS13(s) && !tls_construct_cert_status_body(s, pkt))
774             || !WPACKET_close(pkt)) {
775         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
776         return 0;
777     }
778
779     return 1;
780 }
781 #endif
782
783 #ifndef OPENSSL_NO_NEXTPROTONEG
784 int tls_construct_stoc_next_proto_neg(SSL *s, WPACKET *pkt, X509 *x,
785                                       size_t chainidx, int *al)
786 {
787     const unsigned char *npa;
788     unsigned int npalen;
789     int ret;
790     int npn_seen = s->s3->npn_seen;
791
792     s->s3->npn_seen = 0;
793     if (!npn_seen || s->ctx->ext.npn_advertised_cb == NULL)
794         return 1;
795
796     ret = s->ctx->ext.npn_advertised_cb(s, &npa, &npalen,
797                                         s->ctx->ext.npn_advertised_cb_arg);
798     if (ret == SSL_TLSEXT_ERR_OK) {
799         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
800                 || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
801             SSLerr(SSL_F_TLS_CONSTRUCT_STOC_NEXT_PROTO_NEG,
802                    ERR_R_INTERNAL_ERROR);
803             return 0;
804         }
805         s->s3->npn_seen = 1;
806     }
807
808     return 1;
809 }
810 #endif
811
812 int tls_construct_stoc_alpn(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
813                             int *al)
814 {
815     if (s->s3->alpn_selected == NULL)
816         return 1;
817
818     if (!WPACKET_put_bytes_u16(pkt,
819                 TLSEXT_TYPE_application_layer_protocol_negotiation)
820             || !WPACKET_start_sub_packet_u16(pkt)
821             || !WPACKET_start_sub_packet_u16(pkt)
822             || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
823                                       s->s3->alpn_selected_len)
824             || !WPACKET_close(pkt)
825             || !WPACKET_close(pkt)) {
826         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_ALPN, ERR_R_INTERNAL_ERROR);
827         return 0;
828     }
829
830     return 1;
831 }
832
833 #ifndef OPENSSL_NO_SRTP
834 int tls_construct_stoc_use_srtp(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
835                                 int *al)
836 {
837     if (s->srtp_profile == NULL)
838         return 1;
839
840     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
841             || !WPACKET_start_sub_packet_u16(pkt)
842             || !WPACKET_put_bytes_u16(pkt, 2)
843             || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
844             || !WPACKET_put_bytes_u8(pkt, 0)
845             || !WPACKET_close(pkt)) {
846         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_USE_SRTP, ERR_R_INTERNAL_ERROR);
847         return 0;
848     }
849
850     return 1;
851 }
852 #endif
853
854 int tls_construct_stoc_etm(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
855                            int *al)
856 {
857     if ((s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) == 0)
858         return 1;
859
860     /*
861      * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
862      * for other cases too.
863      */
864     if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
865         || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
866         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
867         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12) {
868         s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
869         return 1;
870     }
871
872     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
873             || !WPACKET_put_bytes_u16(pkt, 0)) {
874         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_ETM, ERR_R_INTERNAL_ERROR);
875         return 0;
876     }
877
878     return 1;
879 }
880
881 int tls_construct_stoc_ems(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
882                            int *al)
883 {
884     if ((s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
885         return 1;
886
887     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
888             || !WPACKET_put_bytes_u16(pkt, 0)) {
889         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_EMS, ERR_R_INTERNAL_ERROR);
890         return 0;
891     }
892
893     return 1;
894 }
895
896 int tls_construct_stoc_key_share(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
897                                  int *al)
898 {
899 #ifndef OPENSSL_NO_TLS1_3
900     unsigned char *encodedPoint;
901     size_t encoded_pt_len = 0;
902     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
903
904     if (s->hit)
905         return 1;
906
907     if (ckey == NULL) {
908         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
909         return 0;
910     }
911
912     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
913             || !WPACKET_start_sub_packet_u16(pkt)
914             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
915         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
916         return 0;
917     }
918
919     skey = ssl_generate_pkey(ckey);
920     if (skey == NULL) {
921         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_MALLOC_FAILURE);
922         return 0;
923     }
924
925     /* Generate encoding of server key */
926     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
927     if (encoded_pt_len == 0) {
928         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_EC_LIB);
929         EVP_PKEY_free(skey);
930         return 0;
931     }
932
933     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
934             || !WPACKET_close(pkt)) {
935         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
936         EVP_PKEY_free(skey);
937         OPENSSL_free(encodedPoint);
938         return 0;
939     }
940     OPENSSL_free(encodedPoint);
941
942     /* This causes the crypto state to be updated based on the derived keys */
943     s->s3->tmp.pkey = skey;
944     if (ssl_derive(s, skey, ckey, 1) == 0) {
945         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_KEY_SHARE, ERR_R_INTERNAL_ERROR);
946         return 0;
947     }
948 #endif
949
950     return 1;
951 }
952
953 int tls_construct_stoc_cryptopro_bug(SSL *s, WPACKET *pkt, X509 *x,
954                                      size_t chainidx, int *al)
955 {
956     const unsigned char cryptopro_ext[36] = {
957         0xfd, 0xe8,         /* 65000 */
958         0x00, 0x20,         /* 32 bytes length */
959         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
960         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
961         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
962         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
963     };
964
965     if (((s->s3->tmp.new_cipher->id & 0xFFFF) != 0x80
966          && (s->s3->tmp.new_cipher->id & 0xFFFF) != 0x81)
967             || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
968         return 1;
969
970     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
971         SSLerr(SSL_F_TLS_CONSTRUCT_STOC_CRYPTOPRO_BUG, ERR_R_INTERNAL_ERROR);
972         return 0;
973     }
974
975     return 1;
976 }