e313e9aa5c35b69a0d13d42cc1e31a1439dc6f83
[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_clienthello_renegotiate(SSL *s, PACKET *pkt, int *al)
18 {
19     unsigned int ilen;
20     const unsigned char *data;
21
22     /* Parse the length byte */
23     if (!PACKET_get_1(pkt, &ilen)
24         || !PACKET_get_bytes(pkt, &data, ilen)) {
25         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_RENEGOTIATE,
26                SSL_R_RENEGOTIATION_ENCODING_ERR);
27         *al = SSL_AD_ILLEGAL_PARAMETER;
28         return 0;
29     }
30
31     /* Check that the extension matches */
32     if (ilen != s->s3->previous_client_finished_len) {
33         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_RENEGOTIATE,
34                SSL_R_RENEGOTIATION_MISMATCH);
35         *al = SSL_AD_HANDSHAKE_FAILURE;
36         return 0;
37     }
38
39     if (memcmp(data, s->s3->previous_client_finished,
40                s->s3->previous_client_finished_len)) {
41         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_RENEGOTIATE,
42                SSL_R_RENEGOTIATION_MISMATCH);
43         *al = SSL_AD_HANDSHAKE_FAILURE;
44         return 0;
45     }
46
47     s->s3->send_connection_binding = 1;
48
49     return 1;
50 }
51
52 int tls_parse_clienthello_server_name(SSL *s, PACKET *pkt, int *al)
53 {
54     unsigned int servname_type;
55     PACKET sni, hostname;
56
57     /*-
58      * The servername extension is treated as follows:
59      *
60      * - Only the hostname type is supported with a maximum length of 255.
61      * - The servername is rejected if too long or if it contains zeros,
62      *   in which case an fatal alert is generated.
63      * - The servername field is maintained together with the session cache.
64      * - When a session is resumed, the servername call back invoked in order
65      *   to allow the application to position itself to the right context.
66      * - The servername is acknowledged if it is new for a session or when
67      *   it is identical to a previously used for the same session.
68      *   Applications can control the behaviour.  They can at any time
69      *   set a 'desirable' servername for a new SSL object. This can be the
70      *   case for example with HTTPS when a Host: header field is received and
71      *   a renegotiation is requested. In this case, a possible servername
72      *   presented in the new client hello is only acknowledged if it matches
73      *   the value of the Host: field.
74      * - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
75      *   if they provide for changing an explicit servername context for the
76      *   session, i.e. when the session has been established with a servername
77      *   extension.
78      * - On session reconnect, the servername extension may be absent.
79      *
80      */
81     if (!PACKET_as_length_prefixed_2(pkt, &sni)
82         /* ServerNameList must be at least 1 byte long. */
83         || PACKET_remaining(&sni) == 0) {
84         *al = SSL_AD_DECODE_ERROR;
85         return 0;
86     }
87
88     /*
89      * Although the server_name extension was intended to be
90      * extensible to new name types, RFC 4366 defined the
91      * syntax inextensibility and OpenSSL 1.0.x parses it as
92      * such.
93      * RFC 6066 corrected the mistake but adding new name types
94      * is nevertheless no longer feasible, so act as if no other
95      * SNI types can exist, to simplify parsing.
96      *
97      * Also note that the RFC permits only one SNI value per type,
98      * i.e., we can only have a single hostname.
99      */
100     if (!PACKET_get_1(&sni, &servname_type)
101         || servname_type != TLSEXT_NAMETYPE_host_name
102         || !PACKET_as_length_prefixed_2(&sni, &hostname)) {
103         *al = SSL_AD_DECODE_ERROR;
104         return 0;
105     }
106
107     if (!s->hit) {
108         if (PACKET_remaining(&hostname) > TLSEXT_MAXLEN_host_name) {
109             *al = TLS1_AD_UNRECOGNIZED_NAME;
110             return 0;
111         }
112
113         if (PACKET_contains_zero_byte(&hostname)) {
114             *al = TLS1_AD_UNRECOGNIZED_NAME;
115             return 0;
116         }
117
118         if (!PACKET_strndup(&hostname, &s->session->tlsext_hostname)) {
119             *al = TLS1_AD_INTERNAL_ERROR;
120             return 0;
121         }
122
123         s->servername_done = 1;
124     } else {
125         /*
126          * TODO(openssl-team): if the SNI doesn't match, we MUST
127          * fall back to a full handshake.
128          */
129         s->servername_done = s->session->tlsext_hostname
130             && PACKET_equal(&hostname, s->session->tlsext_hostname,
131                             strlen(s->session->tlsext_hostname));
132     }
133
134     return 1;
135 }
136
137 #ifndef OPENSSL_NO_SRP
138 int tls_parse_clienthello_srp(SSL *s, PACKET *pkt, int *al)
139 {
140     PACKET srp_I;
141
142     if (!PACKET_as_length_prefixed_1(pkt, &srp_I)
143             || PACKET_contains_zero_byte(&srp_I)) {
144         *al = SSL_AD_DECODE_ERROR;
145         return 0;
146     }
147
148     /*
149      * TODO(openssl-team): currently, we re-authenticate the user
150      * upon resumption. Instead, we MUST ignore the login.
151      */
152     if (!PACKET_strndup(&srp_I, &s->srp_ctx.login)) {
153         *al = TLS1_AD_INTERNAL_ERROR;
154         return 0;
155     }
156
157     return 1;
158 }
159 #endif
160
161 #ifndef OPENSSL_NO_EC
162 int tls_parse_clienthello_ec_pt_formats(SSL *s, PACKET *pkt, int *al)
163 {
164     PACKET ec_point_format_list;
165
166     if (!PACKET_as_length_prefixed_1(pkt, &ec_point_format_list)
167         || PACKET_remaining(&ec_point_format_list) == 0) {
168         *al = SSL_AD_DECODE_ERROR;
169         return 0;
170     }
171
172     if (!s->hit) {
173         if (!PACKET_memdup(&ec_point_format_list,
174                            &s->session->tlsext_ecpointformatlist,
175                            &s->session->tlsext_ecpointformatlist_length)) {
176             *al = TLS1_AD_INTERNAL_ERROR;
177             return 0;
178         }
179     }
180
181     return 1;
182 }
183 #endif                          /* OPENSSL_NO_EC */
184
185 int tls_parse_clienthello_session_ticket(SSL *s, PACKET *pkt, int *al)
186 {
187     if (s->tls_session_ticket_ext_cb &&
188             !s->tls_session_ticket_ext_cb(s, PACKET_data(pkt),
189                                           PACKET_remaining(pkt),
190                                           s->tls_session_ticket_ext_cb_arg)) {
191         *al = TLS1_AD_INTERNAL_ERROR;
192         return 0;
193     }
194
195     return 1;
196 }
197
198 int tls_parse_clienthello_sig_algs(SSL *s, PACKET *pkt, int *al)
199 {
200     PACKET supported_sig_algs;
201
202     if (!PACKET_as_length_prefixed_2(pkt, &supported_sig_algs)
203             || (PACKET_remaining(&supported_sig_algs) % 2) != 0
204             || PACKET_remaining(&supported_sig_algs) == 0) {
205         *al = SSL_AD_DECODE_ERROR;
206         return 0;
207     }
208
209     if (!s->hit && !tls1_save_sigalgs(s, PACKET_data(&supported_sig_algs),
210                                       PACKET_remaining(&supported_sig_algs))) {
211         *al = TLS1_AD_INTERNAL_ERROR;
212         return 0;
213     }
214
215     return 1;
216 }
217
218 int tls_parse_clienthello_status_request(SSL *s, PACKET *pkt, int *al)
219 {
220     if (!PACKET_get_1(pkt, (unsigned int *)&s->tlsext_status_type)) {
221         *al = SSL_AD_DECODE_ERROR;
222         return 0;
223     }
224 #ifndef OPENSSL_NO_OCSP
225     if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp) {
226         const unsigned char *ext_data;
227         PACKET responder_id_list, exts;
228         if (!PACKET_get_length_prefixed_2 (pkt, &responder_id_list)) {
229             *al = SSL_AD_DECODE_ERROR;
230             return 0;
231         }
232
233         /*
234          * We remove any OCSP_RESPIDs from a previous handshake
235          * to prevent unbounded memory growth - CVE-2016-6304
236          */
237         sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
238         if (PACKET_remaining(&responder_id_list) > 0) {
239             s->tlsext_ocsp_ids = sk_OCSP_RESPID_new_null();
240             if (s->tlsext_ocsp_ids == NULL) {
241                 *al = SSL_AD_INTERNAL_ERROR;
242                 return 0;
243             }
244         } else {
245             s->tlsext_ocsp_ids = NULL;
246         }
247
248         while (PACKET_remaining(&responder_id_list) > 0) {
249             OCSP_RESPID *id;
250             PACKET responder_id;
251             const unsigned char *id_data;
252
253             if (!PACKET_get_length_prefixed_2(&responder_id_list,
254                                               &responder_id)
255                     || PACKET_remaining(&responder_id) == 0) {
256                 *al = SSL_AD_DECODE_ERROR;
257                 return 0;
258             }
259
260             id_data = PACKET_data(&responder_id);
261             /* TODO(size_t): Convert d2i_* to size_t */
262             id = d2i_OCSP_RESPID(NULL, &id_data,
263                                  (int)PACKET_remaining(&responder_id));
264             if (id == NULL) {
265                 *al = SSL_AD_DECODE_ERROR;
266                 return 0;
267             }
268
269             if (id_data != PACKET_end(&responder_id)) {
270                 OCSP_RESPID_free(id);
271                 *al = SSL_AD_DECODE_ERROR;
272                 return 0;
273             }
274
275             if (!sk_OCSP_RESPID_push(s->tlsext_ocsp_ids, id)) {
276                 OCSP_RESPID_free(id);
277                 *al = SSL_AD_INTERNAL_ERROR;
278                 return 0;
279             }
280         }
281
282         /* Read in request_extensions */
283         if (!PACKET_as_length_prefixed_2(pkt, &exts)) {
284             *al = SSL_AD_DECODE_ERROR;
285             return 0;
286         }
287
288         if (PACKET_remaining(&exts) > 0) {
289             ext_data = PACKET_data(&exts);
290             sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
291                                        X509_EXTENSION_free);
292             s->tlsext_ocsp_exts =
293                 d2i_X509_EXTENSIONS(NULL, &ext_data,
294                                     (int)PACKET_remaining(&exts));
295             if (s->tlsext_ocsp_exts == NULL || ext_data != PACKET_end(&exts)) {
296                 *al = SSL_AD_DECODE_ERROR;
297                 return 0;
298             }
299         }
300     } else
301 #endif
302     {
303         /*
304          * We don't know what to do with any other type so ignore it.
305          */
306         s->tlsext_status_type = -1;
307     }
308
309     return 1;
310 }
311
312 #ifndef OPENSSL_NO_NEXTPROTONEG
313 int tls_parse_clienthello_npn(SSL *s, PACKET *pkt, int *al)
314 {
315     if (s->s3->tmp.finish_md_len == 0) {
316         /*-
317          * We shouldn't accept this extension on a
318          * renegotiation.
319          *
320          * s->new_session will be set on renegotiation, but we
321          * probably shouldn't rely that it couldn't be set on
322          * the initial renegotiation too in certain cases (when
323          * there's some other reason to disallow resuming an
324          * earlier session -- the current code won't be doing
325          * anything like that, but this might change).
326          *
327          * A valid sign that there's been a previous handshake
328          * in this connection is if s->s3->tmp.finish_md_len >
329          * 0.  (We are talking about a check that will happen
330          * in the Hello protocol round, well before a new
331          * Finished message could have been computed.)
332          */
333         s->s3->next_proto_neg_seen = 1;
334     }
335
336     return 1;
337 }
338 #endif
339
340 /*
341  * Save the ALPN extension in a ClientHello.
342  * pkt: the contents of the ALPN extension, not including type and length.
343  * al: a pointer to the  alert value to send in the event of a failure.
344  * returns: 1 on success, 0 on error.
345  */
346 int tls_parse_clienthello_alpn(SSL *s, PACKET *pkt, int *al)
347 {
348     PACKET protocol_list, save_protocol_list, protocol;
349
350     if (s->s3->tmp.finish_md_len != 0)
351         return 1;
352
353     if (!PACKET_as_length_prefixed_2(pkt, &protocol_list)
354         || PACKET_remaining(&protocol_list) < 2) {
355         *al = SSL_AD_DECODE_ERROR;
356         return 0;
357     }
358
359     save_protocol_list = protocol_list;
360     do {
361         /* Protocol names can't be empty. */
362         if (!PACKET_get_length_prefixed_1(&protocol_list, &protocol)
363                 || PACKET_remaining(&protocol) == 0) {
364             *al = SSL_AD_DECODE_ERROR;
365             return 0;
366         }
367     } while (PACKET_remaining(&protocol_list) != 0);
368
369     if (!PACKET_memdup(&save_protocol_list,
370                        &s->s3->alpn_proposed, &s->s3->alpn_proposed_len)) {
371         *al = TLS1_AD_INTERNAL_ERROR;
372         return 0;
373     }
374
375     return 1;
376 }
377
378 #ifndef OPENSSL_NO_SRTP
379 int tls_parse_clienthello_use_srtp(SSL *s, PACKET *pkt, int *al)
380 {
381     SRTP_PROTECTION_PROFILE *sprof;
382     STACK_OF(SRTP_PROTECTION_PROFILE) *srvr;
383     unsigned int ct, mki_len, id;
384     int i, srtp_pref;
385     PACKET subpkt;
386
387     /* Ignore this if we have no SRTP profiles */
388     if (SSL_get_srtp_profiles(s) == NULL)
389         return 1;
390
391     /* Pull off the length of the cipher suite list  and check it is even */
392     if (!PACKET_get_net_2(pkt, &ct)
393         || (ct & 1) != 0 || !PACKET_get_sub_packet(pkt, &subpkt, ct)) {
394         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
395                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
396         *al = SSL_AD_DECODE_ERROR;
397         return 0;
398     }
399
400     srvr = SSL_get_srtp_profiles(s);
401     s->srtp_profile = NULL;
402     /* Search all profiles for a match initially */
403     srtp_pref = sk_SRTP_PROTECTION_PROFILE_num(srvr);
404
405     while (PACKET_remaining(&subpkt)) {
406         if (!PACKET_get_net_2(&subpkt, &id)) {
407             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
408                    SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
409             *al = SSL_AD_DECODE_ERROR;
410             return 0;
411         }
412
413         /*
414          * Only look for match in profiles of higher preference than
415          * current match.
416          * If no profiles have been have been configured then this
417          * does nothing.
418          */
419         for (i = 0; i < srtp_pref; i++) {
420             sprof = sk_SRTP_PROTECTION_PROFILE_value(srvr, i);
421             if (sprof->id == id) {
422                 s->srtp_profile = sprof;
423                 srtp_pref = i;
424                 break;
425             }
426         }
427     }
428
429     /*
430      * Now extract the MKI value as a sanity check, but discard it for now
431      */
432     if (!PACKET_get_1(pkt, &mki_len)) {
433         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP,
434                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
435         *al = SSL_AD_DECODE_ERROR;
436         return 0;
437     }
438
439     if (!PACKET_forward(pkt, mki_len)
440         || PACKET_remaining(pkt)) {
441         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
442         *al = SSL_AD_DECODE_ERROR;
443         return 0;
444     }
445
446     return 1;
447 }
448 #endif
449
450 int tls_parse_clienthello_etm(SSL *s, PACKET *pkt, int *al)
451 {
452     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC))
453         s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
454
455     return 1;
456 }
457
458 /*
459  * Checks a list of |groups| to determine if the |group_id| is in it. If it is
460  * and |checkallow| is 1 then additionally check if the group is allowed to be
461  * used. Returns 1 if the group is in the list (and allowed if |checkallow| is
462  * 1) or 0 otherwise.
463  */
464 static int check_in_list(SSL *s, unsigned int group_id,
465                          const unsigned char *groups, size_t num_groups,
466                          int checkallow)
467 {
468     size_t i;
469
470     if (groups == NULL || num_groups == 0)
471         return 0;
472
473     for (i = 0; i < num_groups; i++, groups += 2) {
474         unsigned int share_id = (groups[0] << 8) | (groups[1]);
475
476         if (group_id == share_id
477                 && (!checkallow || tls_curve_allowed(s, groups,
478                                                      SSL_SECOP_CURVE_CHECK))) {
479             break;
480         }
481     }
482
483     /* If i == num_groups then not in the list */
484     return i < num_groups;
485 }
486
487 /*
488  * Process a key_share extension received in the ClientHello. |pkt| contains
489  * the raw PACKET data for the extension. Returns 1 on success or 0 on failure.
490  * If a failure occurs then |*al| is set to an appropriate alert value.
491  */
492 int tls_parse_clienthello_key_share(SSL *s, PACKET *pkt, int *al)
493 {
494     unsigned int group_id;
495     PACKET key_share_list, encoded_pt;
496     const unsigned char *clntcurves, *srvrcurves;
497     size_t clnt_num_curves, srvr_num_curves;
498     int group_nid, found = 0;
499     unsigned int curve_flags;
500
501     if (s->hit)
502         return 1;
503
504     /* Sanity check */
505     if (s->s3->peer_tmp != NULL) {
506         *al = SSL_AD_INTERNAL_ERROR;
507         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
508         return 0;
509     }
510
511     if (!PACKET_as_length_prefixed_2(pkt, &key_share_list)) {
512         *al = SSL_AD_HANDSHAKE_FAILURE;
513         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
514         return 0;
515     }
516
517     /* Get our list of supported curves */
518     if (!tls1_get_curvelist(s, 0, &srvrcurves, &srvr_num_curves)) {
519         *al = SSL_AD_INTERNAL_ERROR;
520         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
521         return 0;
522     }
523
524     /* Get the clients list of supported curves */
525     if (!tls1_get_curvelist(s, 1, &clntcurves, &clnt_num_curves)) {
526         *al = SSL_AD_INTERNAL_ERROR;
527         SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_INTERNAL_ERROR);
528         return 0;
529     }
530
531     while (PACKET_remaining(&key_share_list) > 0) {
532         if (!PACKET_get_net_2(&key_share_list, &group_id)
533                 || !PACKET_get_length_prefixed_2(&key_share_list, &encoded_pt)
534                 || PACKET_remaining(&encoded_pt) == 0) {
535             *al = SSL_AD_HANDSHAKE_FAILURE;
536             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE,
537                    SSL_R_LENGTH_MISMATCH);
538             return 0;
539         }
540
541         /*
542          * If we already found a suitable key_share we loop through the
543          * rest to verify the structure, but don't process them.
544          */
545         if (found)
546             continue;
547
548         /* Check if this share is in supported_groups sent from client */
549         if (!check_in_list(s, group_id, clntcurves, clnt_num_curves, 0)) {
550             *al = SSL_AD_HANDSHAKE_FAILURE;
551             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
552             return 0;
553         }
554
555         /* Check if this share is for a group we can use */
556         if (!check_in_list(s, group_id, srvrcurves, srvr_num_curves, 1)) {
557             /* Share not suitable */
558             continue;
559         }
560
561         group_nid = tls1_ec_curve_id2nid(group_id, &curve_flags);
562
563         if (group_nid == 0) {
564             *al = SSL_AD_INTERNAL_ERROR;
565             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE,
566                    SSL_R_UNABLE_TO_FIND_ECDH_PARAMETERS);
567             return 0;
568         }
569
570         if ((curve_flags & TLS_CURVE_TYPE) == TLS_CURVE_CUSTOM) {
571             /* Can happen for some curves, e.g. X25519 */
572             EVP_PKEY *key = EVP_PKEY_new();
573
574             if (key == NULL || !EVP_PKEY_set_type(key, group_nid)) {
575                 *al = SSL_AD_INTERNAL_ERROR;
576                 SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_EVP_LIB);
577                 EVP_PKEY_free(key);
578                 return 0;
579             }
580             s->s3->peer_tmp = key;
581         } else {
582             /* Set up EVP_PKEY with named curve as parameters */
583             EVP_PKEY_CTX *pctx = EVP_PKEY_CTX_new_id(EVP_PKEY_EC, NULL);
584             if (pctx == NULL
585                     || EVP_PKEY_paramgen_init(pctx) <= 0
586                     || EVP_PKEY_CTX_set_ec_paramgen_curve_nid(pctx,
587                                                               group_nid) <= 0
588                     || EVP_PKEY_paramgen(pctx, &s->s3->peer_tmp) <= 0) {
589                 *al = SSL_AD_INTERNAL_ERROR;
590                 SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, ERR_R_EVP_LIB);
591                 EVP_PKEY_CTX_free(pctx);
592                 return 0;
593             }
594             EVP_PKEY_CTX_free(pctx);
595             pctx = NULL;
596         }
597         s->s3->group_id = group_id;
598
599         if (!EVP_PKEY_set1_tls_encodedpoint(s->s3->peer_tmp,
600                 PACKET_data(&encoded_pt),
601                 PACKET_remaining(&encoded_pt))) {
602             *al = SSL_AD_DECODE_ERROR;
603             SSLerr(SSL_F_TLS_PARSE_CLIENTHELLO_KEY_SHARE, SSL_R_BAD_ECPOINT);
604             return 0;
605         }
606
607         found = 1;
608     }
609
610     return 1;
611 }
612
613 #ifndef OPENSSL_NO_EC
614 int tls_parse_clienthello_supported_groups(SSL *s, PACKET *pkt, int *al)
615 {
616     PACKET supported_groups_list;
617
618     /* Each group is 2 bytes and we must have at least 1. */
619     if (!PACKET_as_length_prefixed_2(pkt, &supported_groups_list)
620             || PACKET_remaining(&supported_groups_list) == 0
621             || (PACKET_remaining(&supported_groups_list) % 2) != 0) {
622         *al = SSL_AD_DECODE_ERROR;
623         return 0;
624     }
625
626     if (!s->hit
627             && !PACKET_memdup(&supported_groups_list,
628                               &s->session->tlsext_supportedgroupslist,
629                               &s->session->tlsext_supportedgroupslist_length)) {
630         *al = SSL_AD_DECODE_ERROR;
631         return 0;
632     }
633
634     return 1;
635 }
636 #endif
637
638 int tls_parse_clienthello_ems(SSL *s, PACKET *pkt, int *al)
639 {
640     /* The extension must always be empty */
641     if (PACKET_remaining(pkt) != 0) {
642         *al = SSL_AD_DECODE_ERROR;
643         return 0;
644     }
645
646     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
647
648     return 1;
649 }
650
651 /*
652  * Process the ALPN extension in a ClientHello.
653  * al: a pointer to the alert value to send in the event of a failure.
654  * returns 1 on success, 0 on error.
655  */
656 static int tls1_alpn_handle_client_hello_late(SSL *s, int *al)
657 {
658     const unsigned char *selected = NULL;
659     unsigned char selected_len = 0;
660
661     if (s->ctx->alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
662         int r = s->ctx->alpn_select_cb(s, &selected, &selected_len,
663                                        s->s3->alpn_proposed,
664                                        (unsigned int)s->s3->alpn_proposed_len,
665                                        s->ctx->alpn_select_cb_arg);
666
667         if (r == SSL_TLSEXT_ERR_OK) {
668             OPENSSL_free(s->s3->alpn_selected);
669             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
670             if (s->s3->alpn_selected == NULL) {
671                 *al = SSL_AD_INTERNAL_ERROR;
672                 return 0;
673             }
674             s->s3->alpn_selected_len = selected_len;
675 #ifndef OPENSSL_NO_NEXTPROTONEG
676             /* ALPN takes precedence over NPN. */
677             s->s3->next_proto_neg_seen = 0;
678 #endif
679         } else {
680             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
681             return 0;
682         }
683     }
684
685     return 1;
686 }
687
688 /*
689  * Upon success, returns 1.
690  * Upon failure, returns 0 and sets |al| to the appropriate fatal alert.
691  */
692 int ssl_check_clienthello_tlsext_late(SSL *s, int *al)
693 {
694     s->tlsext_status_expected = 0;
695
696     /*
697      * If status request then ask callback what to do. Note: this must be
698      * called after servername callbacks in case the certificate has changed,
699      * and must be called after the cipher has been chosen because this may
700      * influence which certificate is sent
701      */
702     if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb) {
703         int ret;
704         CERT_PKEY *certpkey;
705         certpkey = ssl_get_server_send_pkey(s);
706         /* If no certificate can't return certificate status */
707         if (certpkey != NULL) {
708             /*
709              * Set current certificate to one we will use so SSL_get_certificate
710              * et al can pick it up.
711              */
712             s->cert->key = certpkey;
713             ret = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
714             switch (ret) {
715                 /* We don't want to send a status request response */
716             case SSL_TLSEXT_ERR_NOACK:
717                 s->tlsext_status_expected = 0;
718                 break;
719                 /* status request response should be sent */
720             case SSL_TLSEXT_ERR_OK:
721                 if (s->tlsext_ocsp_resp)
722                     s->tlsext_status_expected = 1;
723                 break;
724                 /* something bad happened */
725             case SSL_TLSEXT_ERR_ALERT_FATAL:
726             default:
727                 *al = SSL_AD_INTERNAL_ERROR;
728                 return 0;
729             }
730         }
731     }
732
733     if (!tls1_alpn_handle_client_hello_late(s, al)) {
734         return 0;
735     }
736
737     return 1;
738 }
739
740 /* Add the server's renegotiation binding */
741 int tls_construct_server_renegotiate(SSL *s, WPACKET *pkt, int *al)
742 {
743     if (!s->s3->send_connection_binding)
744         return 1;
745
746     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
747             || !WPACKET_start_sub_packet_u16(pkt)
748             || !WPACKET_start_sub_packet_u8(pkt)
749             || !WPACKET_memcpy(pkt, s->s3->previous_client_finished,
750                                s->s3->previous_client_finished_len)
751             || !WPACKET_memcpy(pkt, s->s3->previous_server_finished,
752                                s->s3->previous_server_finished_len)
753             || !WPACKET_close(pkt)
754             || !WPACKET_close(pkt)) {
755         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
756         return 0;
757     }
758
759     return 1;
760 }
761
762 int tls_construct_server_server_name(SSL *s, WPACKET *pkt, int *al)
763 {
764     if (s->hit || s->servername_done != 1
765             || s->session->tlsext_hostname == NULL)
766         return 1;
767
768     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
769             || !WPACKET_put_bytes_u16(pkt, 0)) {
770         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_SERVER_NAME, ERR_R_INTERNAL_ERROR);
771         return 0;
772     }
773
774     return 1;
775 }
776
777 #ifndef OPENSSL_NO_EC
778 int tls_construct_server_ec_pt_formats(SSL *s, WPACKET *pkt, int *al)
779 {
780     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
781     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
782     int using_ecc = (alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA);
783     using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
784     const unsigned char *plist;
785     size_t plistlen;
786
787     if (!using_ecc)
788         return 1;
789
790     tls1_get_formatlist(s, &plist, &plistlen);
791
792     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
793             || !WPACKET_start_sub_packet_u16(pkt)
794             || !WPACKET_sub_memcpy_u8(pkt, plist, plistlen)
795             || !WPACKET_close(pkt)) {
796         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
797         return 0;
798     }
799
800     return 1;
801 }
802 #endif
803
804 int tls_construct_server_session_ticket(SSL *s, WPACKET *pkt, int *al)
805 {
806     if (!s->tlsext_ticket_expected || !tls_use_ticket(s)) {
807         s->tlsext_ticket_expected = 0;
808         return 1;
809     }
810
811     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
812             || !WPACKET_put_bytes_u16(pkt, 0)) {
813         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
814         return 0;
815     }
816
817     return 1;
818 }
819
820 int tls_construct_server_status_request(SSL *s, WPACKET *pkt, int *al)
821 {
822     if (!s->tlsext_status_expected)
823         return 1;
824
825     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
826             || !WPACKET_put_bytes_u16(pkt, 0)) {
827         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
828         return 0;
829     }
830
831     return 1;
832 }
833
834
835 #ifndef OPENSSL_NO_NEXTPROTONEG
836 int tls_construct_server_next_proto_neg(SSL *s, WPACKET *pkt, int *al)
837 {
838     const unsigned char *npa;
839     unsigned int npalen;
840     int ret;
841     int next_proto_neg_seen = s->s3->next_proto_neg_seen;
842
843     s->s3->next_proto_neg_seen = 0;
844     if (!next_proto_neg_seen || s->ctx->next_protos_advertised_cb == NULL)
845         return 1;
846
847     ret = s->ctx->next_protos_advertised_cb(s, &npa, &npalen,
848                                       s->ctx->next_protos_advertised_cb_arg);
849     if (ret == SSL_TLSEXT_ERR_OK) {
850         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
851                 || !WPACKET_sub_memcpy_u16(pkt, npa, npalen)) {
852             SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_NEXT_PROTO_NEG,
853                    ERR_R_INTERNAL_ERROR);
854             return 0;
855         }
856         s->s3->next_proto_neg_seen = 1;
857     }
858
859     return 1;
860 }
861 #endif
862
863 int tls_construct_server_alpn(SSL *s, WPACKET *pkt, int *al)
864 {
865     if (s->s3->alpn_selected == NULL)
866         return 1;
867
868     if (!WPACKET_put_bytes_u16(pkt,
869                 TLSEXT_TYPE_application_layer_protocol_negotiation)
870             || !WPACKET_start_sub_packet_u16(pkt)
871             || !WPACKET_start_sub_packet_u16(pkt)
872             || !WPACKET_sub_memcpy_u8(pkt, s->s3->alpn_selected,
873                                       s->s3->alpn_selected_len)
874             || !WPACKET_close(pkt)
875             || !WPACKET_close(pkt)) {
876         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_ALPN, ERR_R_INTERNAL_ERROR);
877         return 0;
878     }
879
880     return 1;
881 }
882
883 #ifndef OPENSSL_NO_SRTP
884 int tls_construct_server_use_srtp(SSL *s, WPACKET *pkt, int *al)
885 {
886     if (s->srtp_profile == NULL)
887         return 1;
888         
889     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
890             || !WPACKET_start_sub_packet_u16(pkt)
891             || !WPACKET_put_bytes_u16(pkt, 2)
892             || !WPACKET_put_bytes_u16(pkt, s->srtp_profile->id)
893             || !WPACKET_put_bytes_u8(pkt, 0)
894             || !WPACKET_close(pkt)) {
895         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_USE_SRTP, ERR_R_INTERNAL_ERROR);
896         return 0;
897     }
898
899     return 1;
900 }
901 #endif
902
903 int tls_construct_server_etm(SSL *s, WPACKET *pkt, int *al)
904 {
905     if ((s->s3->flags & TLS1_FLAGS_ENCRYPT_THEN_MAC) == 0)
906         return 1;
907
908     /*
909      * Don't use encrypt_then_mac if AEAD or RC4 might want to disable
910      * for other cases too.
911      */
912     if (s->s3->tmp.new_cipher->algorithm_mac == SSL_AEAD
913         || s->s3->tmp.new_cipher->algorithm_enc == SSL_RC4
914         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT
915         || s->s3->tmp.new_cipher->algorithm_enc == SSL_eGOST2814789CNT12) {
916         s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
917         return 1;
918     }
919
920     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
921             || !WPACKET_put_bytes_u16(pkt, 0)) {
922         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_ETM, ERR_R_INTERNAL_ERROR);
923         return 0;
924     }
925
926     return 1;
927 }
928
929 int tls_construct_server_ems(SSL *s, WPACKET *pkt, int *al)
930 {
931     if ((s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) == 0)
932         return 1;
933
934     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
935             || !WPACKET_put_bytes_u16(pkt, 0)) {
936         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_EMS, ERR_R_INTERNAL_ERROR);
937         return 0;
938     }
939
940     return 1;
941 }
942
943 int tls_construct_server_key_share(SSL *s, WPACKET *pkt, int *al)
944 {
945     unsigned char *encodedPoint;
946     size_t encoded_pt_len = 0;
947     EVP_PKEY *ckey = s->s3->peer_tmp, *skey = NULL;
948
949     if (s->hit)
950         return 1;
951
952     if (ckey == NULL) {
953         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
954         return 0;
955     }
956
957     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
958             || !WPACKET_start_sub_packet_u16(pkt)
959             || !WPACKET_put_bytes_u16(pkt, s->s3->group_id)) {
960         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
961         return 0;
962     }
963
964     skey = ssl_generate_pkey(ckey);
965     if (skey == NULL) {
966         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_MALLOC_FAILURE);
967         return 0;
968     }
969
970     /* Generate encoding of server key */
971     encoded_pt_len = EVP_PKEY_get1_tls_encodedpoint(skey, &encodedPoint);
972     if (encoded_pt_len == 0) {
973         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_EC_LIB);
974         EVP_PKEY_free(skey);
975         return 0;
976     }
977
978     if (!WPACKET_sub_memcpy_u16(pkt, encodedPoint, encoded_pt_len)
979             || !WPACKET_close(pkt)) {
980         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
981         EVP_PKEY_free(skey);
982         OPENSSL_free(encodedPoint);
983         return 0;
984     }
985     OPENSSL_free(encodedPoint);
986
987     /* This causes the crypto state to be updated based on the derived keys */
988     s->s3->tmp.pkey = skey;
989     if (ssl_derive(s, skey, ckey, 1) == 0) {
990         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
991         return 0;
992     }
993
994     return 1;
995 }
996
997 int tls_construct_server_cryptopro_bug(SSL *s, WPACKET *pkt, int *al)
998 {
999     const unsigned char cryptopro_ext[36] = {
1000         0xfd, 0xe8,         /* 65000 */
1001         0x00, 0x20,         /* 32 bytes length */
1002         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85,
1003         0x03, 0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06,
1004         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08,
1005         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17
1006     };
1007
1008     if (((s->s3->tmp.new_cipher->id & 0xFFFF) != 0x80
1009          && (s->s3->tmp.new_cipher->id & 0xFFFF) != 0x81)
1010             || (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG) == 0)
1011         return 1;
1012
1013     if (!WPACKET_memcpy(pkt, cryptopro_ext, sizeof(cryptopro_ext))) {
1014         SSLerr(SSL_F_TLS_CONSTRUCT_SERVER_CRYPTOPRO_BUG, ERR_R_INTERNAL_ERROR);
1015         return 0;
1016     }
1017
1018     return 1;
1019 }