93d4178ed95fbf4a9d19eab2a38cff3180e24a5f
[oweals/openssl.git] / ssl / statem / extensions_clnt.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 <assert.h>
11 #include <openssl/ocsp.h>
12 #include "../ssl_locl.h"
13 #include "statem_locl.h"
14
15 int tls_construct_client_renegotiate(SSL *s, WPACKET *pkt, int *al)
16 {
17     /* Add RI if renegotiating */
18     if (!s->renegotiate)
19         return 1;
20
21     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
22             || !WPACKET_start_sub_packet_u16(pkt)
23             || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
24                                s->s3->previous_client_finished_len)
25             || !WPACKET_close(pkt)) {
26         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_RENEGOTIATE, ERR_R_INTERNAL_ERROR);
27         return 0;
28     }
29
30     return 1;
31 }
32
33 int tls_construct_client_server_name(SSL *s, WPACKET *pkt, int *al)
34 {
35     if (s->tlsext_hostname == NULL)
36         return 1;
37
38     /* Add TLS extension servername to the Client Hello message */
39     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
40                /* Sub-packet for server_name extension */
41             || !WPACKET_start_sub_packet_u16(pkt)
42                /* Sub-packet for servername list (always 1 hostname)*/
43             || !WPACKET_start_sub_packet_u16(pkt)
44             || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
45             || !WPACKET_sub_memcpy_u16(pkt, s->tlsext_hostname,
46                                        strlen(s->tlsext_hostname))
47             || !WPACKET_close(pkt)
48             || !WPACKET_close(pkt)) {
49         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SERVER_NAME, ERR_R_INTERNAL_ERROR);
50         return 0;
51     }
52
53     return 1;
54 }
55
56 #ifndef OPENSSL_NO_SRP
57 int tls_construct_client_srp(SSL *s, WPACKET *pkt, int *al)
58 {
59     /* Add SRP username if there is one */
60     if (s->srp_ctx.login == NULL)
61         return 1;
62
63     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
64                /* Sub-packet for SRP extension */
65             || !WPACKET_start_sub_packet_u16(pkt)
66             || !WPACKET_start_sub_packet_u8(pkt)
67                /* login must not be zero...internal error if so */
68             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
69             || !WPACKET_memcpy(pkt, s->srp_ctx.login,
70                                strlen(s->srp_ctx.login))
71             || !WPACKET_close(pkt)
72             || !WPACKET_close(pkt)) {
73         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SRP, ERR_R_INTERNAL_ERROR);
74         return 0;
75     }
76
77     return 1;
78 }
79 #endif
80
81 #ifndef OPENSSL_NO_EC
82 static int use_ecc(SSL *s)
83 {
84     int using_ecc = 0;
85     int i;
86     unsigned long alg_k, alg_a;
87     STACK_OF(SSL_CIPHER) *cipher_stack = NULL;
88
89     /* See if we support any ECC ciphersuites */
90     if (s->version == SSL3_VERSION)
91         return 0;
92
93
94     cipher_stack = SSL_get_ciphers(s);
95
96     for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++) {
97         const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
98
99         alg_k = c->algorithm_mkey;
100         alg_a = c->algorithm_auth;
101         if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
102             || (alg_a & SSL_aECDSA)
103             || c->min_tls >= TLS1_3_VERSION) {
104             using_ecc = 1;
105             break;
106         }
107     }
108
109     return using_ecc;
110 }
111
112 int tls_construct_client_ec_pt_formats(SSL *s, WPACKET *pkt, int *al)
113 {
114     const unsigned char *pformats;
115     size_t num_formats;
116
117     if (!use_ecc(s))
118         return 1;
119
120     /* Add TLS extension ECPointFormats to the ClientHello message */
121
122     tls1_get_formatlist(s, &pformats, &num_formats);
123
124     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
125                /* Sub-packet for formats extension */
126             || !WPACKET_start_sub_packet_u16(pkt)
127             || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
128             || !WPACKET_close(pkt)) {
129         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
130         return 0;
131     }
132
133     return 1;
134 }
135
136
137 int tls_construct_client_supported_groups(SSL *s, WPACKET *pkt, int *al)
138 {
139     const unsigned char *pcurves = NULL, *pcurvestmp;
140     size_t num_curves = 0, i;
141
142     if (!use_ecc(s))
143         return 1;
144
145     /*
146      * Add TLS extension supported_groups to the ClientHello message
147      */
148     /* TODO(TLS1.3): Add support for DHE groups */
149     pcurves = s->tlsext_supportedgroupslist;
150     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
151         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
152                ERR_R_INTERNAL_ERROR);
153         return 0;
154     }
155     pcurvestmp = pcurves;
156
157     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
158                /* Sub-packet for supported_groups extension */
159             || !WPACKET_start_sub_packet_u16(pkt)
160             || !WPACKET_start_sub_packet_u16(pkt)) {
161         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
162                ERR_R_INTERNAL_ERROR);
163         return 0;
164     }
165     /* Copy curve ID if supported */
166     for (i = 0; i < num_curves; i++, pcurvestmp += 2) {
167         if (tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED)) {
168             if (!WPACKET_put_bytes_u8(pkt, pcurvestmp[0])
169                 || !WPACKET_put_bytes_u8(pkt, pcurvestmp[1])) {
170                     SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
171                            ERR_R_INTERNAL_ERROR);
172                     return 0;
173                 }
174         }
175     }
176     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
177         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_GROUPS,
178                ERR_R_INTERNAL_ERROR);
179         return 0;
180     }
181
182     return 1;
183 }
184 #endif
185
186 int tls_construct_client_session_ticket(SSL *s, WPACKET *pkt, int *al)
187 {
188     size_t ticklen;
189
190     if (!tls_use_ticket(s))
191         return 1;
192
193     if (!s->new_session && s->session != NULL
194             && s->session->tlsext_tick != NULL) {
195         ticklen = s->session->tlsext_ticklen;
196     } else if (s->session && s->tlsext_session_ticket != NULL
197                && s->tlsext_session_ticket->data != NULL) {
198         ticklen = s->tlsext_session_ticket->length;
199         s->session->tlsext_tick = OPENSSL_malloc(ticklen);
200         if (s->session->tlsext_tick == NULL) {
201             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SESSION_TICKET,
202                    ERR_R_INTERNAL_ERROR);
203             return 0;
204         }
205         memcpy(s->session->tlsext_tick,
206                s->tlsext_session_ticket->data, ticklen);
207         s->session->tlsext_ticklen = ticklen;
208     } else {
209         ticklen = 0;
210     }
211
212     if (ticklen == 0 && s->tlsext_session_ticket != NULL &&
213             s->tlsext_session_ticket->data == NULL)
214         return 1;
215
216     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
217             || !WPACKET_sub_memcpy_u16(pkt, s->session->tlsext_tick, ticklen)) {
218         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
219         return 0;
220     }
221
222     return 1;
223 }
224
225 int tls_construct_client_sig_algs(SSL *s, WPACKET *pkt, int *al)
226 {
227     size_t salglen;
228     const unsigned char *salg;
229
230     if (!SSL_CLIENT_USE_SIGALGS(s))
231         return 1;
232
233     salglen = tls12_get_psigalgs(s, &salg);
234
235     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
236                /* Sub-packet for sig-algs extension */
237             || !WPACKET_start_sub_packet_u16(pkt)
238                /* Sub-packet for the actual list */
239             || !WPACKET_start_sub_packet_u16(pkt)
240             || !tls12_copy_sigalgs(s, pkt, salg, salglen)
241             || !WPACKET_close(pkt)
242             || !WPACKET_close(pkt)) {
243         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SIG_ALGS, ERR_R_INTERNAL_ERROR);
244         return 0;
245     }
246
247     return 1;
248 }
249
250 #ifndef OPENSSL_NO_OCSP
251 int tls_construct_client_status_request(SSL *s, WPACKET *pkt, int *al)
252 {
253     int i;
254
255     if (s->tlsext_status_type != TLSEXT_STATUSTYPE_ocsp)
256         return 1;
257
258     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
259                /* Sub-packet for status request extension */
260             || !WPACKET_start_sub_packet_u16(pkt)
261             || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
262                /* Sub-packet for the ids */
263             || !WPACKET_start_sub_packet_u16(pkt)) {
264         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
265         return 0;
266     }
267     for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++) {
268         unsigned char *idbytes;
269         int idlen;
270         OCSP_RESPID *id;
271
272         id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
273         idlen = i2d_OCSP_RESPID(id, NULL);
274         if (idlen <= 0
275                    /* Sub-packet for an individual id */
276                 || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
277                 || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
278             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
279                    ERR_R_INTERNAL_ERROR);
280             return 0;
281         }
282     }
283     if (!WPACKET_close(pkt)
284             || !WPACKET_start_sub_packet_u16(pkt)) {
285         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
286         return 0;
287     }
288     if (s->tlsext_ocsp_exts) {
289         unsigned char *extbytes;
290         int extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
291
292         if (extlen < 0) {
293             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
294                    ERR_R_INTERNAL_ERROR);
295             return 0;
296         }
297         if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
298                 || i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &extbytes)
299                    != extlen) {
300             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST,
301                    ERR_R_INTERNAL_ERROR);
302             return 0;
303        }
304     }
305     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
306         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
307         return 0;
308     }
309
310     return 1;
311 }
312 #endif
313
314 #ifndef OPENSSL_NO_NEXTPROTONEG
315 int tls_construct_client_npn(SSL *s, WPACKET *pkt, int *al)
316 {
317     if (s->ctx->next_proto_select_cb == NULL || s->s3->tmp.finish_md_len != 0)
318         return 1;
319
320     /*
321      * The client advertises an empty extension to indicate its support
322      * for Next Protocol Negotiation
323      */
324     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
325             || !WPACKET_put_bytes_u16(pkt, 0)) {
326         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_NPN, ERR_R_INTERNAL_ERROR);
327         return 0;
328     }
329
330     return 1;
331 }
332 #endif
333
334 int tls_construct_client_alpn(SSL *s, WPACKET *pkt, int *al)
335 {
336     s->s3->alpn_sent = 0;
337
338     /*
339      * finish_md_len is non-zero during a renegotiation, so
340      * this avoids sending ALPN during the renegotiation
341      */
342     if (s->alpn_client_proto_list == NULL || s->s3->tmp.finish_md_len != 0)
343         return 1;
344
345     if (!WPACKET_put_bytes_u16(pkt,
346                 TLSEXT_TYPE_application_layer_protocol_negotiation)
347                /* Sub-packet ALPN extension */
348             || !WPACKET_start_sub_packet_u16(pkt)
349             || !WPACKET_sub_memcpy_u16(pkt, s->alpn_client_proto_list,
350                                        s->alpn_client_proto_list_len)
351             || !WPACKET_close(pkt)) {
352         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_ALPN, ERR_R_INTERNAL_ERROR);
353         return 0;
354     }
355     s->s3->alpn_sent = 1;
356
357     return 1;
358 }
359
360
361 #ifndef OPENSSL_NO_SRTP
362 int tls_construct_client_use_srtp(SSL *s, WPACKET *pkt, int *al)
363 {
364     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
365     SRTP_PROTECTION_PROFILE *prof;
366     int i, ct;
367
368     if (clnt == NULL)
369         return 1;
370
371     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
372                /* Sub-packet for SRTP extension */
373             || !WPACKET_start_sub_packet_u16(pkt)
374                /* Sub-packet for the protection profile list */
375             || !WPACKET_start_sub_packet_u16(pkt)) {
376         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
377         return 0;
378     }
379     ct = sk_SRTP_PROTECTION_PROFILE_num(clnt);
380     for (i = 0; i < ct; i++) {
381         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
382         if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
383             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
384             return 0;
385         }
386     }
387     if (!WPACKET_close(pkt)
388                /* Add an empty use_mki value */
389             || !WPACKET_put_bytes_u8(pkt, 0)
390             || !WPACKET_close(pkt)) {
391         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_USE_SRTP, ERR_R_INTERNAL_ERROR);
392         return 0;
393     }
394
395     return 1;
396 }
397 #endif
398
399 int tls_construct_client_etm(SSL *s, WPACKET *pkt, int *al)
400 {
401     if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
402         return 1;
403
404     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
405             || !WPACKET_put_bytes_u16(pkt, 0)) {
406         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_ETM, ERR_R_INTERNAL_ERROR);
407         return 0;
408     }
409
410     return 1;
411 }
412
413 #ifndef OPENSSL_NO_CT
414 int tls_construct_client_sct(SSL *s, WPACKET *pkt, int *al)
415 {
416     if (s->ct_validation_callback == NULL)
417         return 1;
418
419     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
420             || !WPACKET_put_bytes_u16(pkt, 0)) {
421         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SCT, ERR_R_INTERNAL_ERROR);
422         return 0;
423     }
424
425     return 1;
426 }
427 #endif
428
429 int tls_construct_client_ems(SSL *s, WPACKET *pkt, int *al)
430 {
431     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
432             || !WPACKET_put_bytes_u16(pkt, 0)) {
433         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_EMS, ERR_R_INTERNAL_ERROR);
434         return 0;
435     }
436
437     return 1;
438 }
439
440 int tls_construct_client_supported_versions(SSL *s, WPACKET *pkt, int *al)
441 {
442     int currv, min_version, max_version, reason;
443
444     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
445             || !WPACKET_start_sub_packet_u16(pkt)
446             || !WPACKET_start_sub_packet_u8(pkt)) {
447         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
448                ERR_R_INTERNAL_ERROR);
449         return 0;
450     }
451
452     reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
453     if (reason != 0) {
454         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS, reason);
455         return 0;
456     }
457
458     /*
459      * TODO(TLS1.3): There is some discussion on the TLS list as to wheter
460      * we should include versions <TLS1.2. For the moment we do. To be
461      * reviewed later.
462      */
463     for (currv = max_version; currv >= min_version; currv--) {
464         /* TODO(TLS1.3): Remove this first if clause prior to release!! */
465         if (currv == TLS1_3_VERSION) {
466             if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
467                 SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
468                        ERR_R_INTERNAL_ERROR);
469                 return 0;
470             }
471         } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
472             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
473                    ERR_R_INTERNAL_ERROR);
474             return 0;
475         }
476     }
477     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
478         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_SUPPORTED_VERSIONS,
479                ERR_R_INTERNAL_ERROR);
480         return 0;
481     }
482
483     return 1;
484 }
485
486
487 int tls_construct_client_key_share(SSL *s, WPACKET *pkt, int *al)
488 {
489     size_t i, sharessent = 0, num_curves = 0;
490     const unsigned char *pcurves = NULL;
491
492     /* key_share extension */
493     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
494                /* Extension data sub-packet */
495             || !WPACKET_start_sub_packet_u16(pkt)
496                /* KeyShare list sub-packet */
497             || !WPACKET_start_sub_packet_u16(pkt)) {
498         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
499         return 0;
500     }
501
502     pcurves = s->tlsext_supportedgroupslist;
503     if (!tls1_get_curvelist(s, 0, &pcurves, &num_curves)) {
504         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
505         return 0;
506     }
507
508     /*
509      * TODO(TLS1.3): Make the number of key_shares sent configurable. For
510      * now, just send one
511      */
512     for (i = 0; i < num_curves && sharessent < 1; i++, pcurves += 2) {
513         unsigned char *encodedPoint = NULL;
514         unsigned int curve_id = 0;
515         EVP_PKEY *key_share_key = NULL;
516         size_t encodedlen;
517
518         if (!tls_curve_allowed(s, pcurves, SSL_SECOP_CURVE_SUPPORTED))
519             continue;
520
521         if (s->s3->tmp.pkey != NULL) {
522             /* Shouldn't happen! */
523             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
524             return 0;
525         }
526
527         /* Generate a key for this key_share */
528         curve_id = (pcurves[0] << 8) | pcurves[1];
529         key_share_key = ssl_generate_pkey_curve(curve_id);
530         if (key_share_key == NULL) {
531             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_EVP_LIB);
532             return 0;
533         }
534
535         /* Encode the public key. */
536         encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
537                                                     &encodedPoint);
538         if (encodedlen == 0) {
539             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_EC_LIB);
540             EVP_PKEY_free(key_share_key);
541             return 0;
542         }
543
544         /* Create KeyShareEntry */
545         if (!WPACKET_put_bytes_u16(pkt, curve_id)
546                 || !WPACKET_sub_memcpy_u16(pkt, encodedPoint, encodedlen)) {
547             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
548             EVP_PKEY_free(key_share_key);
549             OPENSSL_free(encodedPoint);
550             return 0;
551         }
552
553         /*
554          * TODO(TLS1.3): When changing to send more than one key_share we're
555          * going to need to be able to save more than one EVP_PKEY. For now
556          * we reuse the existing tmp.pkey
557          */
558         s->s3->group_id = curve_id;
559         s->s3->tmp.pkey = key_share_key;
560         sharessent++;
561         OPENSSL_free(encodedPoint);
562     }
563
564     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
565         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_KEY_SHARE, ERR_R_INTERNAL_ERROR);
566         return 0;
567     }
568
569     return 1;
570 }
571
572 int tls_construct_client_padding(SSL *s, WPACKET *pkt, int *al)
573 {
574     unsigned char *padbytes;
575     size_t hlen;
576
577     if ((s->options & SSL_OP_TLSEXT_PADDING) == 0)
578         return 1;
579
580     /*
581      * Add padding to workaround bugs in F5 terminators. See
582      * https://tools.ietf.org/html/draft-agl-tls-padding-03 NB: because this
583      * code works out the length of all existing extensions it MUST always
584      * appear last.
585      */
586     if (!WPACKET_get_total_written(pkt, &hlen)) {
587         SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_PADDING, ERR_R_INTERNAL_ERROR);
588         return 0;
589     }
590
591     if (hlen > 0xff && hlen < 0x200) {
592         hlen = 0x200 - hlen;
593         if (hlen >= 4)
594             hlen -= 4;
595         else
596             hlen = 0;
597
598         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
599                 || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
600             SSLerr(SSL_F_TLS_CONSTRUCT_CLIENT_PADDING, ERR_R_INTERNAL_ERROR);
601             return 0;
602         }
603         memset(padbytes, 0, hlen);
604     }
605
606     return 1;
607 }
608
609 /*
610  * Parse the server's renegotiation binding and abort if it's not right
611  */
612 int tls_parse_server_renegotiate(SSL *s, PACKET *pkt, int *al)
613 {
614     size_t expected_len = s->s3->previous_client_finished_len
615         + s->s3->previous_server_finished_len;
616     size_t ilen;
617     const unsigned char *data;
618
619     /* Check for logic errors */
620     assert(expected_len == 0 || s->s3->previous_client_finished_len != 0);
621     assert(expected_len == 0 || s->s3->previous_server_finished_len != 0);
622
623     /* Parse the length byte */
624     if (!PACKET_get_1_len(pkt, &ilen)) {
625         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
626                SSL_R_RENEGOTIATION_ENCODING_ERR);
627         *al = SSL_AD_ILLEGAL_PARAMETER;
628         return 0;
629     }
630
631     /* Consistency check */
632     if (PACKET_remaining(pkt) != ilen) {
633         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
634                SSL_R_RENEGOTIATION_ENCODING_ERR);
635         *al = SSL_AD_ILLEGAL_PARAMETER;
636         return 0;
637     }
638
639     /* Check that the extension matches */
640     if (ilen != expected_len) {
641         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
642                SSL_R_RENEGOTIATION_MISMATCH);
643         *al = SSL_AD_HANDSHAKE_FAILURE;
644         return 0;
645     }
646
647     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_client_finished_len)
648         || memcmp(data, s->s3->previous_client_finished,
649                   s->s3->previous_client_finished_len) != 0) {
650         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
651                SSL_R_RENEGOTIATION_MISMATCH);
652         *al = SSL_AD_HANDSHAKE_FAILURE;
653         return 0;
654     }
655
656     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_server_finished_len)
657         || memcmp(data, s->s3->previous_server_finished,
658                   s->s3->previous_server_finished_len) != 0) {
659         SSLerr(SSL_F_TLS_PARSE_SERVER_RENEGOTIATE,
660                SSL_R_RENEGOTIATION_MISMATCH);
661         *al = SSL_AD_ILLEGAL_PARAMETER;
662         return 0;
663     }
664     s->s3->send_connection_binding = 1;
665
666     return 1;
667 }
668
669 int tls_parse_server_server_name(SSL *s, PACKET *pkt, int *al)
670 {
671     if (s->tlsext_hostname == NULL || PACKET_remaining(pkt) > 0) {
672         *al = SSL_AD_UNRECOGNIZED_NAME;
673         return 0;
674     }
675
676     if (!s->hit) {
677         if (s->session->tlsext_hostname != NULL) {
678             *al = SSL_AD_INTERNAL_ERROR;
679             return 0;
680         }
681         s->session->tlsext_hostname = OPENSSL_strdup(s->tlsext_hostname);
682         if (s->session->tlsext_hostname == NULL) {
683             *al = SSL_AD_INTERNAL_ERROR;
684             return 0;
685         }
686     }
687
688     return 1;
689 }
690
691 #ifndef OPENSSL_NO_EC
692 int tls_parse_server_ec_pt_formats(SSL *s, PACKET *pkt, int *al)
693 {
694     unsigned int ecpointformatlist_length;
695     PACKET ecptformatlist;
696
697     if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) {
698         *al = SSL_AD_DECODE_ERROR;
699         return 0;
700     }
701     if (!s->hit) {
702         ecpointformatlist_length = PACKET_remaining(&ecptformatlist);
703         s->session->tlsext_ecpointformatlist_length = 0;
704
705         OPENSSL_free(s->session->tlsext_ecpointformatlist);
706         s->session->tlsext_ecpointformatlist =
707              OPENSSL_malloc(ecpointformatlist_length);
708         if (s->session->tlsext_ecpointformatlist == NULL) {
709             *al = SSL_AD_INTERNAL_ERROR;
710             return 0;
711         }
712
713         s->session->tlsext_ecpointformatlist_length = ecpointformatlist_length;
714
715         if (!PACKET_copy_bytes(&ecptformatlist,
716                                s->session->tlsext_ecpointformatlist,
717                                ecpointformatlist_length)) {
718             *al = SSL_AD_INTERNAL_ERROR;
719             return 0;
720         }
721     }
722
723     return 1;
724 }
725 #endif
726
727 int tls_parse_server_session_ticket(SSL *s, PACKET *pkt, int *al)
728 {
729     if (s->tls_session_ticket_ext_cb &&
730         !s->tls_session_ticket_ext_cb(s, PACKET_data(pkt),
731                                       PACKET_remaining(pkt),
732                                       s->tls_session_ticket_ext_cb_arg)) {
733         *al = SSL_AD_INTERNAL_ERROR;
734         return 0;
735     }
736     if (!tls_use_ticket(s) || PACKET_remaining(pkt) > 0) {
737         *al = SSL_AD_UNSUPPORTED_EXTENSION;
738         return 0;
739     }
740     s->tlsext_ticket_expected = 1;
741
742     return 1;
743 }
744
745 #ifndef OPENSSL_NO_OCSP
746 int tls_parse_server_status_request(SSL *s, PACKET *pkt, int *al)
747 {
748     /*
749      * MUST be empty and only sent if we've requested a status
750      * request message.
751      */
752     if (s->tlsext_status_type == -1 || PACKET_remaining(pkt) > 0) {
753         *al = SSL_AD_UNSUPPORTED_EXTENSION;
754         return 0;
755     }
756     /* Set flag to expect CertificateStatus message */
757     s->tlsext_status_expected = 1;
758
759     return 1;
760 }
761 #endif
762
763
764 #ifndef OPENSSL_NO_CT
765 int tls_parse_server_sct(SSL *s, PACKET *pkt, int *al)
766 {
767     /*
768      * Only take it if we asked for it - i.e if there is no CT validation
769      * callback set, then a custom extension MAY be processing it, so we
770      * need to let control continue to flow to that.
771      */
772     if (s->ct_validation_callback != NULL) {
773         size_t size = PACKET_remaining(pkt);
774
775         /* Simply copy it off for later processing */
776         if (s->tlsext_scts != NULL) {
777             OPENSSL_free(s->tlsext_scts);
778             s->tlsext_scts = NULL;
779         }
780         s->tlsext_scts_len = size;
781         if (size > 0) {
782             s->tlsext_scts = OPENSSL_malloc(size);
783             if (s->tlsext_scts == NULL
784                     || !PACKET_copy_bytes(pkt, s->tlsext_scts, size)) {
785                 *al = SSL_AD_INTERNAL_ERROR;
786                 return 0;
787             }
788         }
789     } else {
790         if (custom_ext_parse(s, 0, TLSEXT_TYPE_signed_certificate_timestamp,
791                              PACKET_data(pkt), PACKET_remaining(pkt), al) <= 0)
792             return 0;
793     }
794
795     return 1;
796 }
797 #endif
798
799
800 #ifndef OPENSSL_NO_NEXTPROTONEG
801 /*
802  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
803  * elements of zero length are allowed and the set of elements must exactly
804  * fill the length of the block. Returns 1 on success or 0 on failure.
805  */
806 static int ssl_next_proto_validate(PACKET *pkt)
807 {
808     PACKET tmp_protocol;
809
810     while (PACKET_remaining(pkt)) {
811         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
812             || PACKET_remaining(&tmp_protocol) == 0)
813             return 0;
814     }
815
816     return 1;
817 }
818
819 int tls_parse_server_npn(SSL *s, PACKET *pkt, int *al)
820 {
821     unsigned char *selected;
822     unsigned char selected_len;
823     PACKET tmppkt;
824
825     if (s->s3->tmp.finish_md_len != 0)
826         return 1;
827
828     /* We must have requested it. */
829     if (s->ctx->next_proto_select_cb == NULL) {
830         *al = SSL_AD_UNSUPPORTED_EXTENSION;
831         return 0;
832     }
833     /* The data must be valid */
834     tmppkt = *pkt;
835     if (!ssl_next_proto_validate(&tmppkt)) {
836         *al = SSL_AD_DECODE_ERROR;
837         return 0;
838     }
839     if (s->ctx->next_proto_select_cb(s, &selected, &selected_len,
840                                      PACKET_data(pkt),
841                                      PACKET_remaining(pkt),
842                                      s->ctx->next_proto_select_cb_arg) !=
843              SSL_TLSEXT_ERR_OK) {
844         *al = SSL_AD_INTERNAL_ERROR;
845         return 0;
846     }
847     /*
848      * Could be non-NULL if server has sent multiple NPN extensions in
849      * a single Serverhello
850      */
851     OPENSSL_free(s->next_proto_negotiated);
852     s->next_proto_negotiated = OPENSSL_malloc(selected_len);
853     if (s->next_proto_negotiated == NULL) {
854         *al = SSL_AD_INTERNAL_ERROR;
855         return 0;
856     }
857
858     memcpy(s->next_proto_negotiated, selected, selected_len);
859     s->next_proto_negotiated_len = selected_len;
860     s->s3->next_proto_neg_seen = 1;
861
862     return 1;
863 }
864 #endif
865
866 int tls_parse_server_alpn(SSL *s, PACKET *pkt, int *al)
867 {
868     size_t len;
869
870     /* We must have requested it. */
871     if (!s->s3->alpn_sent) {
872         *al = SSL_AD_UNSUPPORTED_EXTENSION;
873         return 0;
874     }
875     /*-
876      * The extension data consists of:
877      *   uint16 list_length
878      *   uint8 proto_length;
879      *   uint8 proto[proto_length];
880      */
881     if (!PACKET_get_net_2_len(pkt, &len)
882         || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len)
883         || PACKET_remaining(pkt) != len) {
884         *al = SSL_AD_DECODE_ERROR;
885         return 0;
886     }
887     OPENSSL_free(s->s3->alpn_selected);
888     s->s3->alpn_selected = OPENSSL_malloc(len);
889     if (s->s3->alpn_selected == NULL) {
890         *al = SSL_AD_INTERNAL_ERROR;
891         return 0;
892     }
893     if (!PACKET_copy_bytes(pkt, s->s3->alpn_selected, len)) {
894         *al = SSL_AD_DECODE_ERROR;
895         return 0;
896     }
897     s->s3->alpn_selected_len = len;
898
899     return 1;
900 }
901
902 #ifndef OPENSSL_NO_SRTP
903 int tls_parse_server_use_srtp(SSL *s, PACKET *pkt, int *al)
904 {
905     unsigned int id, ct, mki;
906     int i;
907     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
908     SRTP_PROTECTION_PROFILE *prof;
909
910     if (!PACKET_get_net_2(pkt, &ct)
911         || ct != 2 || !PACKET_get_net_2(pkt, &id)
912         || !PACKET_get_1(pkt, &mki)
913         || PACKET_remaining(pkt) != 0) {
914         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP,
915                SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
916         *al = SSL_AD_DECODE_ERROR;
917         return 0;
918     }
919
920     if (mki != 0) {
921         /* Must be no MKI, since we never offer one */
922         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP, SSL_R_BAD_SRTP_MKI_VALUE);
923         *al = SSL_AD_ILLEGAL_PARAMETER;
924         return 0;
925     }
926
927     clnt = SSL_get_srtp_profiles(s);
928
929     /* Throw an error if the server gave us an unsolicited extension */
930     if (clnt == NULL) {
931         SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP, SSL_R_NO_SRTP_PROFILES);
932         *al = SSL_AD_DECODE_ERROR;
933         return 0;
934     }
935
936     /*
937      * Check to see if the server gave us something we support (and
938      * presumably offered)
939      */
940     for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) {
941         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
942
943         if (prof->id == id) {
944             s->srtp_profile = prof;
945             *al = 0;
946             return 1;
947         }
948     }
949
950     SSLerr(SSL_F_TLS_PARSE_SERVER_USE_SRTP,
951            SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
952     *al = SSL_AD_DECODE_ERROR;
953     return 0;
954 }
955 #endif
956
957 int tls_parse_server_etm(SSL *s, PACKET *pkt, int *al)
958 {
959     /* Ignore if inappropriate ciphersuite */
960     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
961             && s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
962             && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
963         s->s3->flags |= TLS1_FLAGS_ENCRYPT_THEN_MAC;
964
965     return 1;
966 }
967
968 int tls_parse_server_ems(SSL *s, PACKET *pkt, int *al)
969 {
970     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
971     if (!s->hit)
972         s->session->flags |= SSL_SESS_FLAG_EXTMS;
973
974     return 1;
975 }
976
977 int tls_parse_server_key_share(SSL *s, PACKET *pkt, int *al)
978 {
979     unsigned int group_id;
980     PACKET encoded_pt;
981     EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
982
983     /* Sanity check */
984     if (ckey == NULL) {
985         *al = SSL_AD_INTERNAL_ERROR;
986         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
987         return 0;
988     }
989
990     if (!PACKET_get_net_2(pkt, &group_id)) {
991         *al = SSL_AD_HANDSHAKE_FAILURE;
992         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
993         return 0;
994     }
995
996     if (group_id != s->s3->group_id) {
997         /*
998          * This isn't for the group that we sent in the original
999          * key_share!
1000          */
1001         *al = SSL_AD_HANDSHAKE_FAILURE;
1002         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1003         return 0;
1004     }
1005
1006     if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt)
1007             || PACKET_remaining(&encoded_pt) == 0) {
1008         *al = SSL_AD_DECODE_ERROR;
1009         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_LENGTH_MISMATCH);
1010         return 0;
1011     }
1012
1013     skey = ssl_generate_pkey(ckey);
1014     if (skey == NULL) {
1015         *al = SSL_AD_INTERNAL_ERROR;
1016         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_MALLOC_FAILURE);
1017         return 0;
1018     }
1019     if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
1020                                         PACKET_remaining(&encoded_pt))) {
1021         *al = SSL_AD_DECODE_ERROR;
1022         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, SSL_R_BAD_ECPOINT);
1023         return 0;
1024     }
1025
1026     if (ssl_derive(s, ckey, skey, 1) == 0) {
1027         *al = SSL_AD_INTERNAL_ERROR;
1028         SSLerr(SSL_F_TLS_PARSE_SERVER_KEY_SHARE, ERR_R_INTERNAL_ERROR);
1029         EVP_PKEY_free(skey);
1030         return 0;
1031     }
1032     EVP_PKEY_free(skey);
1033
1034     return 1;
1035 }
1036
1037 static int ssl_scan_serverhello_tlsext(SSL *s, PACKET *pkt, int *al)
1038 {
1039     RAW_EXTENSION *extensions = NULL;
1040     PACKET extpkt;
1041
1042 #ifndef OPENSSL_NO_NEXTPROTONEG
1043     s->s3->next_proto_neg_seen = 0;
1044 #endif
1045     s->tlsext_ticket_expected = 0;
1046
1047     OPENSSL_free(s->s3->alpn_selected);
1048     s->s3->alpn_selected = NULL;
1049
1050     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
1051
1052     s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
1053
1054     if (!PACKET_as_length_prefixed_2(pkt, &extpkt)) {
1055         /* Extensions block may be completely absent in SSLv3 */
1056         if (s->version != SSL3_VERSION || PACKET_remaining(pkt) != 0) {
1057             *al = SSL_AD_DECODE_ERROR;
1058             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_BAD_LENGTH);
1059             return 0;
1060         }
1061         PACKET_null_init(&extpkt);
1062     }
1063
1064     /*
1065      * TODO(TLS1.3): We give multiple contexts for now until we're ready to
1066      * give something more specific
1067      */
1068
1069     if (!tls_collect_extensions(s, &extpkt, EXT_TLS1_2_SERVER_HELLO
1070                                             | EXT_TLS1_3_SERVER_HELLO
1071                                             | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1072                                             | EXT_TLS1_3_CERTIFICATE,
1073                                 &extensions, al))
1074         return 0;
1075
1076     /*
1077      * Determine if we need to see RI. Strictly speaking if we want to avoid
1078      * an attack we should *always* see RI even on initial server hello
1079      * because the client doesn't see any renegotiation during an attack.
1080      * However this would mean we could not connect to any server which
1081      * doesn't support RI so for the immediate future tolerate RI absence
1082      */
1083     if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
1084             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
1085             && !extensions[TLSEXT_IDX_renegotiate].present) {
1086         *al = SSL_AD_HANDSHAKE_FAILURE;
1087         SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT,
1088                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
1089         return 0;
1090     }
1091
1092     if (!tls_parse_all_extensions(s, EXT_TLS1_2_SERVER_HELLO
1093                                      | EXT_TLS1_3_SERVER_HELLO
1094                                      | EXT_TLS1_3_ENCRYPTED_EXTENSIONS
1095                                      | EXT_TLS1_3_CERTIFICATE,
1096                                   extensions,al))
1097         return 0;
1098
1099     if (s->hit) {
1100         /*
1101          * Check extended master secret extension is consistent with
1102          * original session.
1103          */
1104         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
1105             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
1106             *al = SSL_AD_HANDSHAKE_FAILURE;
1107             SSLerr(SSL_F_SSL_SCAN_SERVERHELLO_TLSEXT, SSL_R_INCONSISTENT_EXTMS);
1108             return 0;
1109         }
1110     }
1111
1112     return 1;
1113 }
1114
1115 static int ssl_check_serverhello_tlsext(SSL *s)
1116 {
1117     int ret = SSL_TLSEXT_ERR_NOACK;
1118     int al = SSL_AD_UNRECOGNIZED_NAME;
1119
1120 #ifndef OPENSSL_NO_EC
1121     /*
1122      * If we are client and using an elliptic curve cryptography cipher
1123      * suite, then if server returns an EC point formats lists extension it
1124      * must contain uncompressed.
1125      */
1126     unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1127     unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1128     if ((s->tlsext_ecpointformatlist != NULL)
1129         && (s->tlsext_ecpointformatlist_length > 0)
1130         && (s->session->tlsext_ecpointformatlist != NULL)
1131         && (s->session->tlsext_ecpointformatlist_length > 0)
1132         && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
1133         /* we are using an ECC cipher */
1134         size_t i;
1135         unsigned char *list;
1136         int found_uncompressed = 0;
1137         list = s->session->tlsext_ecpointformatlist;
1138         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++) {
1139             if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed) {
1140                 found_uncompressed = 1;
1141                 break;
1142             }
1143         }
1144         if (!found_uncompressed) {
1145             SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,
1146                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1147             return -1;
1148         }
1149     }
1150     ret = SSL_TLSEXT_ERR_OK;
1151 #endif                          /* OPENSSL_NO_EC */
1152
1153     if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0)
1154         ret =
1155             s->ctx->tlsext_servername_callback(s, &al,
1156                                                s->ctx->tlsext_servername_arg);
1157     else if (s->initial_ctx != NULL
1158              && s->initial_ctx->tlsext_servername_callback != 0)
1159         ret =
1160             s->initial_ctx->tlsext_servername_callback(s, &al,
1161                                                        s->
1162                                                        initial_ctx->tlsext_servername_arg);
1163
1164     /*
1165      * Ensure we get sensible values passed to tlsext_status_cb in the event
1166      * that we don't receive a status message
1167      */
1168     OPENSSL_free(s->tlsext_ocsp_resp);
1169     s->tlsext_ocsp_resp = NULL;
1170     s->tlsext_ocsp_resplen = 0;
1171
1172     switch (ret) {
1173     case SSL_TLSEXT_ERR_ALERT_FATAL:
1174         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1175         return -1;
1176
1177     case SSL_TLSEXT_ERR_ALERT_WARNING:
1178         ssl3_send_alert(s, SSL3_AL_WARNING, al);
1179         return 1;
1180
1181     case SSL_TLSEXT_ERR_NOACK:
1182         s->servername_done = 0;
1183     default:
1184         return 1;
1185     }
1186 }
1187
1188 int ssl_parse_serverhello_tlsext(SSL *s, PACKET *pkt)
1189 {
1190     int al = -1;
1191     if (s->version < SSL3_VERSION)
1192         return 1;
1193     if (ssl_scan_serverhello_tlsext(s, pkt, &al) <= 0) {
1194         ssl3_send_alert(s, SSL3_AL_FATAL, al);
1195         return 0;
1196     }
1197
1198     if (ssl_check_serverhello_tlsext(s) <= 0) {
1199         SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT, SSL_R_SERVERHELLO_TLSEXT);
1200         return 0;
1201     }
1202     return 1;
1203 }