bd025d7c023a4dc73c1fc0c9cc5a7f743b762a64
[openssl.git] / ssl / statem / extensions_clnt.c
1 /*
2  * Copyright 2016-2018 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 "internal/cryptlib.h"
13 #include "statem_locl.h"
14
15 EXT_RETURN tls_construct_ctos_renegotiate(SSL *s, WPACKET *pkt,
16                                           unsigned int context, X509 *x,
17                                           size_t chainidx)
18 {
19     /* Add RI if renegotiating */
20     if (!s->renegotiate)
21         return EXT_RETURN_NOT_SENT;
22
23     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_renegotiate)
24             || !WPACKET_start_sub_packet_u16(pkt)
25             || !WPACKET_sub_memcpy_u8(pkt, s->s3->previous_client_finished,
26                                s->s3->previous_client_finished_len)
27             || !WPACKET_close(pkt)) {
28         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_RENEGOTIATE,
29                  ERR_R_INTERNAL_ERROR);
30         return EXT_RETURN_FAIL;
31     }
32
33     return EXT_RETURN_SENT;
34 }
35
36 EXT_RETURN tls_construct_ctos_server_name(SSL *s, WPACKET *pkt,
37                                           unsigned int context, X509 *x,
38                                           size_t chainidx)
39 {
40     if (s->ext.hostname == NULL)
41         return EXT_RETURN_NOT_SENT;
42
43     /* Add TLS extension servername to the Client Hello message */
44     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_server_name)
45                /* Sub-packet for server_name extension */
46             || !WPACKET_start_sub_packet_u16(pkt)
47                /* Sub-packet for servername list (always 1 hostname)*/
48             || !WPACKET_start_sub_packet_u16(pkt)
49             || !WPACKET_put_bytes_u8(pkt, TLSEXT_NAMETYPE_host_name)
50             || !WPACKET_sub_memcpy_u16(pkt, s->ext.hostname,
51                                        strlen(s->ext.hostname))
52             || !WPACKET_close(pkt)
53             || !WPACKET_close(pkt)) {
54         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_SERVER_NAME,
55                  ERR_R_INTERNAL_ERROR);
56         return EXT_RETURN_FAIL;
57     }
58
59     return EXT_RETURN_SENT;
60 }
61
62 /* Push a Max Fragment Len extension into ClientHello */
63 EXT_RETURN tls_construct_ctos_maxfragmentlen(SSL *s, WPACKET *pkt,
64                                              unsigned int context, X509 *x,
65                                              size_t chainidx)
66 {
67     if (s->ext.max_fragment_len_mode == TLSEXT_max_fragment_length_DISABLED)
68         return EXT_RETURN_NOT_SENT;
69
70     /* Add Max Fragment Length extension if client enabled it. */
71     /*-
72      * 4 bytes for this extension type and extension length
73      * 1 byte for the Max Fragment Length code value.
74      */
75     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_max_fragment_length)
76             /* Sub-packet for Max Fragment Length extension (1 byte) */
77             || !WPACKET_start_sub_packet_u16(pkt)
78             || !WPACKET_put_bytes_u8(pkt, s->ext.max_fragment_len_mode)
79             || !WPACKET_close(pkt)) {
80         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
81                  SSL_F_TLS_CONSTRUCT_CTOS_MAXFRAGMENTLEN, ERR_R_INTERNAL_ERROR);
82         return EXT_RETURN_FAIL;
83     }
84
85     return EXT_RETURN_SENT;
86 }
87
88 #ifndef OPENSSL_NO_SRP
89 EXT_RETURN tls_construct_ctos_srp(SSL *s, WPACKET *pkt, unsigned int context,
90                                   X509 *x, size_t chainidx)
91 {
92     /* Add SRP username if there is one */
93     if (s->srp_ctx.login == NULL)
94         return EXT_RETURN_NOT_SENT;
95
96     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_srp)
97                /* Sub-packet for SRP extension */
98             || !WPACKET_start_sub_packet_u16(pkt)
99             || !WPACKET_start_sub_packet_u8(pkt)
100                /* login must not be zero...internal error if so */
101             || !WPACKET_set_flags(pkt, WPACKET_FLAGS_NON_ZERO_LENGTH)
102             || !WPACKET_memcpy(pkt, s->srp_ctx.login,
103                                strlen(s->srp_ctx.login))
104             || !WPACKET_close(pkt)
105             || !WPACKET_close(pkt)) {
106         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_SRP,
107                  ERR_R_INTERNAL_ERROR);
108         return EXT_RETURN_FAIL;
109     }
110
111     return EXT_RETURN_SENT;
112 }
113 #endif
114
115 #ifndef OPENSSL_NO_EC
116 static int use_ecc(SSL *s)
117 {
118     int i, end;
119     unsigned long alg_k, alg_a;
120     STACK_OF(SSL_CIPHER) *cipher_stack = NULL;
121
122     /* See if we support any ECC ciphersuites */
123     if (s->version == SSL3_VERSION)
124         return 0;
125
126     cipher_stack = SSL_get_ciphers(s);
127     end = sk_SSL_CIPHER_num(cipher_stack);
128     for (i = 0; i < end; i++) {
129         const SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
130
131         alg_k = c->algorithm_mkey;
132         alg_a = c->algorithm_auth;
133         if ((alg_k & (SSL_kECDHE | SSL_kECDHEPSK))
134                 || (alg_a & SSL_aECDSA)
135                 || c->min_tls >= TLS1_3_VERSION)
136             return 1;
137     }
138
139     return 0;
140 }
141
142 EXT_RETURN tls_construct_ctos_ec_pt_formats(SSL *s, WPACKET *pkt,
143                                             unsigned int context, X509 *x,
144                                             size_t chainidx)
145 {
146     const unsigned char *pformats;
147     size_t num_formats;
148
149     if (!use_ecc(s))
150         return EXT_RETURN_NOT_SENT;
151
152     /* Add TLS extension ECPointFormats to the ClientHello message */
153     tls1_get_formatlist(s, &pformats, &num_formats);
154
155     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_ec_point_formats)
156                /* Sub-packet for formats extension */
157             || !WPACKET_start_sub_packet_u16(pkt)
158             || !WPACKET_sub_memcpy_u8(pkt, pformats, num_formats)
159             || !WPACKET_close(pkt)) {
160         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
161                  SSL_F_TLS_CONSTRUCT_CTOS_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
162         return EXT_RETURN_FAIL;
163     }
164
165     return EXT_RETURN_SENT;
166 }
167
168 EXT_RETURN tls_construct_ctos_supported_groups(SSL *s, WPACKET *pkt,
169                                                unsigned int context, X509 *x,
170                                                size_t chainidx)
171 {
172     const uint16_t *pgroups = NULL;
173     size_t num_groups = 0, i;
174
175     if (!use_ecc(s))
176         return EXT_RETURN_NOT_SENT;
177
178     /*
179      * Add TLS extension supported_groups to the ClientHello message
180      */
181     /* TODO(TLS1.3): Add support for DHE groups */
182     tls1_get_supported_groups(s, &pgroups, &num_groups);
183
184     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_groups)
185                /* Sub-packet for supported_groups extension */
186             || !WPACKET_start_sub_packet_u16(pkt)
187             || !WPACKET_start_sub_packet_u16(pkt)) {
188         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
189                  SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
190                  ERR_R_INTERNAL_ERROR);
191         return EXT_RETURN_FAIL;
192     }
193     /* Copy curve ID if supported */
194     for (i = 0; i < num_groups; i++) {
195         uint16_t ctmp = pgroups[i];
196
197         if (tls_curve_allowed(s, ctmp, SSL_SECOP_CURVE_SUPPORTED)) {
198             if (!WPACKET_put_bytes_u16(pkt, ctmp)) {
199                     SSLfatal(s, SSL_AD_INTERNAL_ERROR,
200                              SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
201                              ERR_R_INTERNAL_ERROR);
202                     return EXT_RETURN_FAIL;
203                 }
204         }
205     }
206     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
207         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
208                  SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_GROUPS,
209                  ERR_R_INTERNAL_ERROR);
210         return EXT_RETURN_FAIL;
211     }
212
213     return EXT_RETURN_SENT;
214 }
215 #endif
216
217 EXT_RETURN tls_construct_ctos_session_ticket(SSL *s, WPACKET *pkt,
218                                              unsigned int context, X509 *x,
219                                              size_t chainidx)
220 {
221     size_t ticklen;
222
223     if (!tls_use_ticket(s))
224         return EXT_RETURN_NOT_SENT;
225
226     if (!s->new_session && s->session != NULL
227             && s->session->ext.tick != NULL
228             && s->session->ssl_version != TLS1_3_VERSION) {
229         ticklen = s->session->ext.ticklen;
230     } else if (s->session && s->ext.session_ticket != NULL
231                && s->ext.session_ticket->data != NULL) {
232         ticklen = s->ext.session_ticket->length;
233         s->session->ext.tick = OPENSSL_malloc(ticklen);
234         if (s->session->ext.tick == NULL) {
235             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
236                      SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET,
237                      ERR_R_INTERNAL_ERROR);
238             return EXT_RETURN_FAIL;
239         }
240         memcpy(s->session->ext.tick,
241                s->ext.session_ticket->data, ticklen);
242         s->session->ext.ticklen = ticklen;
243     } else {
244         ticklen = 0;
245     }
246
247     if (ticklen == 0 && s->ext.session_ticket != NULL &&
248             s->ext.session_ticket->data == NULL)
249         return EXT_RETURN_NOT_SENT;
250
251     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_session_ticket)
252             || !WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick, ticklen)) {
253         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
254                  SSL_F_TLS_CONSTRUCT_CTOS_SESSION_TICKET, ERR_R_INTERNAL_ERROR);
255         return EXT_RETURN_FAIL;
256     }
257
258     return EXT_RETURN_SENT;
259 }
260
261 EXT_RETURN tls_construct_ctos_sig_algs(SSL *s, WPACKET *pkt,
262                                        unsigned int context, X509 *x,
263                                        size_t chainidx)
264 {
265     size_t salglen;
266     const uint16_t *salg;
267
268     if (!SSL_CLIENT_USE_SIGALGS(s))
269         return EXT_RETURN_NOT_SENT;
270
271     salglen = tls12_get_psigalgs(s, 1, &salg);
272     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signature_algorithms)
273                /* Sub-packet for sig-algs extension */
274             || !WPACKET_start_sub_packet_u16(pkt)
275                /* Sub-packet for the actual list */
276             || !WPACKET_start_sub_packet_u16(pkt)
277             || !tls12_copy_sigalgs(s, pkt, salg, salglen)
278             || !WPACKET_close(pkt)
279             || !WPACKET_close(pkt)) {
280         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_SIG_ALGS,
281                  ERR_R_INTERNAL_ERROR);
282         return EXT_RETURN_FAIL;
283     }
284
285     return EXT_RETURN_SENT;
286 }
287
288 #ifndef OPENSSL_NO_OCSP
289 EXT_RETURN tls_construct_ctos_status_request(SSL *s, WPACKET *pkt,
290                                              unsigned int context, X509 *x,
291                                              size_t chainidx)
292 {
293     int i;
294
295     /* This extension isn't defined for client Certificates */
296     if (x != NULL)
297         return EXT_RETURN_NOT_SENT;
298
299     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp)
300         return EXT_RETURN_NOT_SENT;
301
302     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_status_request)
303                /* Sub-packet for status request extension */
304             || !WPACKET_start_sub_packet_u16(pkt)
305             || !WPACKET_put_bytes_u8(pkt, TLSEXT_STATUSTYPE_ocsp)
306                /* Sub-packet for the ids */
307             || !WPACKET_start_sub_packet_u16(pkt)) {
308         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
309                  SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
310         return EXT_RETURN_FAIL;
311     }
312     for (i = 0; i < sk_OCSP_RESPID_num(s->ext.ocsp.ids); i++) {
313         unsigned char *idbytes;
314         OCSP_RESPID *id = sk_OCSP_RESPID_value(s->ext.ocsp.ids, i);
315         int idlen = i2d_OCSP_RESPID(id, NULL);
316
317         if (idlen <= 0
318                    /* Sub-packet for an individual id */
319                 || !WPACKET_sub_allocate_bytes_u16(pkt, idlen, &idbytes)
320                 || i2d_OCSP_RESPID(id, &idbytes) != idlen) {
321             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
322                      SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
323                      ERR_R_INTERNAL_ERROR);
324             return EXT_RETURN_FAIL;
325         }
326     }
327     if (!WPACKET_close(pkt)
328             || !WPACKET_start_sub_packet_u16(pkt)) {
329         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
330                  SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
331         return EXT_RETURN_FAIL;
332     }
333     if (s->ext.ocsp.exts) {
334         unsigned char *extbytes;
335         int extlen = i2d_X509_EXTENSIONS(s->ext.ocsp.exts, NULL);
336
337         if (extlen < 0) {
338             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
339                      SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
340                      ERR_R_INTERNAL_ERROR);
341             return EXT_RETURN_FAIL;
342         }
343         if (!WPACKET_allocate_bytes(pkt, extlen, &extbytes)
344                 || i2d_X509_EXTENSIONS(s->ext.ocsp.exts, &extbytes)
345                    != extlen) {
346             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
347                      SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST,
348                      ERR_R_INTERNAL_ERROR);
349             return EXT_RETURN_FAIL;
350        }
351     }
352     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
353         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
354                  SSL_F_TLS_CONSTRUCT_CTOS_STATUS_REQUEST, ERR_R_INTERNAL_ERROR);
355         return EXT_RETURN_FAIL;
356     }
357
358     return EXT_RETURN_SENT;
359 }
360 #endif
361
362 #ifndef OPENSSL_NO_NEXTPROTONEG
363 EXT_RETURN tls_construct_ctos_npn(SSL *s, WPACKET *pkt, unsigned int context,
364                                   X509 *x, size_t chainidx)
365 {
366     if (s->ctx->ext.npn_select_cb == NULL || !SSL_IS_FIRST_HANDSHAKE(s))
367         return EXT_RETURN_NOT_SENT;
368
369     /*
370      * The client advertises an empty extension to indicate its support
371      * for Next Protocol Negotiation
372      */
373     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_next_proto_neg)
374             || !WPACKET_put_bytes_u16(pkt, 0)) {
375         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_NPN,
376                  ERR_R_INTERNAL_ERROR);
377         return EXT_RETURN_FAIL;
378     }
379
380     return EXT_RETURN_SENT;
381 }
382 #endif
383
384 EXT_RETURN tls_construct_ctos_alpn(SSL *s, WPACKET *pkt, unsigned int context,
385                                    X509 *x, size_t chainidx)
386 {
387     s->s3->alpn_sent = 0;
388
389     if (s->ext.alpn == NULL || !SSL_IS_FIRST_HANDSHAKE(s))
390         return EXT_RETURN_NOT_SENT;
391
392     if (!WPACKET_put_bytes_u16(pkt,
393                 TLSEXT_TYPE_application_layer_protocol_negotiation)
394                /* Sub-packet ALPN extension */
395             || !WPACKET_start_sub_packet_u16(pkt)
396             || !WPACKET_sub_memcpy_u16(pkt, s->ext.alpn, s->ext.alpn_len)
397             || !WPACKET_close(pkt)) {
398         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_ALPN,
399                  ERR_R_INTERNAL_ERROR);
400         return EXT_RETURN_FAIL;
401     }
402     s->s3->alpn_sent = 1;
403
404     return EXT_RETURN_SENT;
405 }
406
407
408 #ifndef OPENSSL_NO_SRTP
409 EXT_RETURN tls_construct_ctos_use_srtp(SSL *s, WPACKET *pkt,
410                                        unsigned int context, X509 *x,
411                                        size_t chainidx)
412 {
413     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt = SSL_get_srtp_profiles(s);
414     int i, end;
415
416     if (clnt == NULL)
417         return EXT_RETURN_NOT_SENT;
418
419     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_use_srtp)
420                /* Sub-packet for SRTP extension */
421             || !WPACKET_start_sub_packet_u16(pkt)
422                /* Sub-packet for the protection profile list */
423             || !WPACKET_start_sub_packet_u16(pkt)) {
424         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP,
425                  ERR_R_INTERNAL_ERROR);
426         return EXT_RETURN_FAIL;
427     }
428
429     end = sk_SRTP_PROTECTION_PROFILE_num(clnt);
430     for (i = 0; i < end; i++) {
431         const SRTP_PROTECTION_PROFILE *prof =
432             sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
433
434         if (prof == NULL || !WPACKET_put_bytes_u16(pkt, prof->id)) {
435             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
436                      SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP, ERR_R_INTERNAL_ERROR);
437             return EXT_RETURN_FAIL;
438         }
439     }
440     if (!WPACKET_close(pkt)
441                /* Add an empty use_mki value */
442             || !WPACKET_put_bytes_u8(pkt, 0)
443             || !WPACKET_close(pkt)) {
444         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_USE_SRTP,
445                  ERR_R_INTERNAL_ERROR);
446         return EXT_RETURN_FAIL;
447     }
448
449     return EXT_RETURN_SENT;
450 }
451 #endif
452
453 EXT_RETURN tls_construct_ctos_etm(SSL *s, WPACKET *pkt, unsigned int context,
454                                   X509 *x, size_t chainidx)
455 {
456     if (s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
457         return EXT_RETURN_NOT_SENT;
458
459     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_encrypt_then_mac)
460             || !WPACKET_put_bytes_u16(pkt, 0)) {
461         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_ETM,
462                  ERR_R_INTERNAL_ERROR);
463         return EXT_RETURN_FAIL;
464     }
465
466     return EXT_RETURN_SENT;
467 }
468
469 #ifndef OPENSSL_NO_CT
470 EXT_RETURN tls_construct_ctos_sct(SSL *s, WPACKET *pkt, unsigned int context,
471                                   X509 *x, size_t chainidx)
472 {
473     if (s->ct_validation_callback == NULL)
474         return EXT_RETURN_NOT_SENT;
475
476     /* Not defined for client Certificates */
477     if (x != NULL)
478         return EXT_RETURN_NOT_SENT;
479
480     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_signed_certificate_timestamp)
481             || !WPACKET_put_bytes_u16(pkt, 0)) {
482         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_SCT,
483                  ERR_R_INTERNAL_ERROR);
484         return EXT_RETURN_FAIL;
485     }
486
487     return EXT_RETURN_SENT;
488 }
489 #endif
490
491 EXT_RETURN tls_construct_ctos_ems(SSL *s, WPACKET *pkt, unsigned int context,
492                                   X509 *x, size_t chainidx)
493 {
494     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_extended_master_secret)
495             || !WPACKET_put_bytes_u16(pkt, 0)) {
496         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_EMS,
497                  ERR_R_INTERNAL_ERROR);
498         return EXT_RETURN_FAIL;
499     }
500
501     return EXT_RETURN_SENT;
502 }
503
504 EXT_RETURN tls_construct_ctos_supported_versions(SSL *s, WPACKET *pkt,
505                                                  unsigned int context, X509 *x,
506                                                  size_t chainidx)
507 {
508     int currv, min_version, max_version, reason;
509
510     reason = ssl_get_min_max_version(s, &min_version, &max_version);
511     if (reason != 0) {
512         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
513                  SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS, reason);
514         return EXT_RETURN_FAIL;
515     }
516
517     /*
518      * Don't include this if we can't negotiate TLSv1.3. We can do a straight
519      * comparison here because we will never be called in DTLS.
520      */
521     if (max_version < TLS1_3_VERSION)
522         return EXT_RETURN_NOT_SENT;
523
524     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_supported_versions)
525             || !WPACKET_start_sub_packet_u16(pkt)
526             || !WPACKET_start_sub_packet_u8(pkt)) {
527         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
528                  SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
529                  ERR_R_INTERNAL_ERROR);
530         return EXT_RETURN_FAIL;
531     }
532
533     /*
534      * TODO(TLS1.3): There is some discussion on the TLS list as to whether
535      * we should include versions <TLS1.2. For the moment we do. To be
536      * reviewed later.
537      */
538     for (currv = max_version; currv >= min_version; currv--) {
539         /* TODO(TLS1.3): Remove this first if clause prior to release!! */
540         if (currv == TLS1_3_VERSION) {
541             if (!WPACKET_put_bytes_u16(pkt, TLS1_3_VERSION_DRAFT)) {
542                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
543                          SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
544                          ERR_R_INTERNAL_ERROR);
545                 return EXT_RETURN_FAIL;
546             }
547         } else if (!WPACKET_put_bytes_u16(pkt, currv)) {
548             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
549                      SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
550                      ERR_R_INTERNAL_ERROR);
551             return EXT_RETURN_FAIL;
552         }
553     }
554     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
555         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
556                  SSL_F_TLS_CONSTRUCT_CTOS_SUPPORTED_VERSIONS,
557                  ERR_R_INTERNAL_ERROR);
558         return EXT_RETURN_FAIL;
559     }
560
561     return EXT_RETURN_SENT;
562 }
563
564 /*
565  * Construct a psk_kex_modes extension.
566  */
567 EXT_RETURN tls_construct_ctos_psk_kex_modes(SSL *s, WPACKET *pkt,
568                                             unsigned int context, X509 *x,
569                                             size_t chainidx)
570 {
571 #ifndef OPENSSL_NO_TLS1_3
572     int nodhe = s->options & SSL_OP_ALLOW_NO_DHE_KEX;
573
574     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk_kex_modes)
575             || !WPACKET_start_sub_packet_u16(pkt)
576             || !WPACKET_start_sub_packet_u8(pkt)
577             || !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE_DHE)
578             || (nodhe && !WPACKET_put_bytes_u8(pkt, TLSEXT_KEX_MODE_KE))
579             || !WPACKET_close(pkt)
580             || !WPACKET_close(pkt)) {
581         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
582                  SSL_F_TLS_CONSTRUCT_CTOS_PSK_KEX_MODES, ERR_R_INTERNAL_ERROR);
583         return EXT_RETURN_FAIL;
584     }
585
586     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_KE_DHE;
587     if (nodhe)
588         s->ext.psk_kex_mode |= TLSEXT_KEX_MODE_FLAG_KE;
589 #endif
590
591     return EXT_RETURN_SENT;
592 }
593
594 #ifndef OPENSSL_NO_TLS1_3
595 static int add_key_share(SSL *s, WPACKET *pkt, unsigned int curve_id)
596 {
597     unsigned char *encoded_point = NULL;
598     EVP_PKEY *key_share_key = NULL;
599     size_t encodedlen;
600
601     if (s->s3->tmp.pkey != NULL) {
602         if (!ossl_assert(s->hello_retry_request == SSL_HRR_PENDING)) {
603             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_ADD_KEY_SHARE,
604                      ERR_R_INTERNAL_ERROR);
605             return 0;
606         }
607         /*
608          * Could happen if we got an HRR that wasn't requesting a new key_share
609          */
610         key_share_key = s->s3->tmp.pkey;
611     } else {
612         key_share_key = ssl_generate_pkey_group(s, curve_id);
613         if (key_share_key == NULL) {
614             /* SSLfatal() already called */
615             return 0;
616         }
617     }
618
619     /* Encode the public key. */
620     encodedlen = EVP_PKEY_get1_tls_encodedpoint(key_share_key,
621                                                 &encoded_point);
622     if (encodedlen == 0) {
623         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_ADD_KEY_SHARE, ERR_R_EC_LIB);
624         goto err;
625     }
626
627     /* Create KeyShareEntry */
628     if (!WPACKET_put_bytes_u16(pkt, curve_id)
629             || !WPACKET_sub_memcpy_u16(pkt, encoded_point, encodedlen)) {
630         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_ADD_KEY_SHARE,
631                  ERR_R_INTERNAL_ERROR);
632         goto err;
633     }
634
635     /*
636      * TODO(TLS1.3): When changing to send more than one key_share we're
637      * going to need to be able to save more than one EVP_PKEY. For now
638      * we reuse the existing tmp.pkey
639      */
640     s->s3->tmp.pkey = key_share_key;
641     s->s3->group_id = curve_id;
642     OPENSSL_free(encoded_point);
643
644     return 1;
645  err:
646     if (s->s3->tmp.pkey == NULL)
647         EVP_PKEY_free(key_share_key);
648     OPENSSL_free(encoded_point);
649     return 0;
650 }
651 #endif
652
653 EXT_RETURN tls_construct_ctos_key_share(SSL *s, WPACKET *pkt,
654                                         unsigned int context, X509 *x,
655                                         size_t chainidx)
656 {
657 #ifndef OPENSSL_NO_TLS1_3
658     size_t i, num_groups = 0;
659     const uint16_t *pgroups = NULL;
660     uint16_t curve_id = 0;
661
662     /* key_share extension */
663     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_key_share)
664                /* Extension data sub-packet */
665             || !WPACKET_start_sub_packet_u16(pkt)
666                /* KeyShare list sub-packet */
667             || !WPACKET_start_sub_packet_u16(pkt)) {
668         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE,
669                  ERR_R_INTERNAL_ERROR);
670         return EXT_RETURN_FAIL;
671     }
672
673     tls1_get_supported_groups(s, &pgroups, &num_groups);
674
675     /*
676      * TODO(TLS1.3): Make the number of key_shares sent configurable. For
677      * now, just send one
678      */
679     if (s->s3->group_id != 0) {
680         curve_id = s->s3->group_id;
681     } else {
682         for (i = 0; i < num_groups; i++) {
683
684             if (!tls_curve_allowed(s, pgroups[i], SSL_SECOP_CURVE_SUPPORTED))
685                 continue;
686
687             curve_id = pgroups[i];
688             break;
689         }
690     }
691
692     if (curve_id == 0) {
693         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE,
694                  SSL_R_NO_SUITABLE_KEY_SHARE);
695         return EXT_RETURN_FAIL;
696     }
697
698     if (!add_key_share(s, pkt, curve_id)) {
699         /* SSLfatal() already called */
700         return EXT_RETURN_FAIL;
701     }
702
703     if (!WPACKET_close(pkt) || !WPACKET_close(pkt)) {
704         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_KEY_SHARE,
705                  ERR_R_INTERNAL_ERROR);
706         return EXT_RETURN_FAIL;
707     }
708     return EXT_RETURN_SENT;
709 #else
710     return EXT_RETURN_NOT_SENT;
711 #endif
712 }
713
714 EXT_RETURN tls_construct_ctos_cookie(SSL *s, WPACKET *pkt, unsigned int context,
715                                      X509 *x, size_t chainidx)
716 {
717     EXT_RETURN ret = EXT_RETURN_FAIL;
718
719     /* Should only be set if we've had an HRR */
720     if (s->ext.tls13_cookie_len == 0)
721         return EXT_RETURN_NOT_SENT;
722
723     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_cookie)
724                /* Extension data sub-packet */
725             || !WPACKET_start_sub_packet_u16(pkt)
726             || !WPACKET_sub_memcpy_u16(pkt, s->ext.tls13_cookie,
727                                        s->ext.tls13_cookie_len)
728             || !WPACKET_close(pkt)) {
729         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_COOKIE,
730                  ERR_R_INTERNAL_ERROR);
731         goto end;
732     }
733
734     ret = EXT_RETURN_SENT;
735  end:
736     OPENSSL_free(s->ext.tls13_cookie);
737     s->ext.tls13_cookie = NULL;
738     s->ext.tls13_cookie_len = 0;
739
740     return ret;
741 }
742
743 EXT_RETURN tls_construct_ctos_early_data(SSL *s, WPACKET *pkt,
744                                          unsigned int context, X509 *x,
745                                          size_t chainidx)
746 {
747     char identity[PSK_MAX_IDENTITY_LEN + 1];
748     const unsigned char *id = NULL;
749     size_t idlen = 0;
750     SSL_SESSION *psksess = NULL;
751     SSL_SESSION *edsess = NULL;
752     const EVP_MD *handmd = NULL;
753
754     if (s->hello_retry_request == SSL_HRR_PENDING)
755         handmd = ssl_handshake_md(s);
756
757     if (s->psk_use_session_cb != NULL
758             && (!s->psk_use_session_cb(s, handmd, &id, &idlen, &psksess)
759                 || (psksess != NULL
760                     && psksess->ssl_version != TLS1_3_VERSION))) {
761         SSL_SESSION_free(psksess);
762         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
763                  SSL_R_BAD_PSK);
764         return EXT_RETURN_FAIL;
765     }
766
767     if (psksess == NULL && s->psk_client_callback != NULL) {
768         unsigned char psk[PSK_MAX_PSK_LEN];
769         size_t psklen = 0;
770
771         memset(identity, 0, sizeof(identity));
772         psklen = s->psk_client_callback(s, NULL, identity, sizeof(identity) - 1,
773                                         psk, sizeof(psk));
774
775         if (psklen > PSK_MAX_PSK_LEN) {
776             SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
777                      SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA, ERR_R_INTERNAL_ERROR);
778             return EXT_RETURN_FAIL;
779         } else if (psklen > 0) {
780             const unsigned char tls13_aes128gcmsha256_id[] = { 0x13, 0x01 };
781             const SSL_CIPHER *cipher;
782
783             idlen = strlen(identity);
784             if (idlen > PSK_MAX_IDENTITY_LEN) {
785                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
786                          SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
787                          ERR_R_INTERNAL_ERROR);
788                 return EXT_RETURN_FAIL;
789             }
790             id = (unsigned char *)identity;
791
792             /*
793              * We found a PSK using an old style callback. We don't know
794              * the digest so we default to SHA256 as per the TLSv1.3 spec
795              */
796             cipher = SSL_CIPHER_find(s, tls13_aes128gcmsha256_id);
797             if (cipher == NULL) {
798                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
799                          SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
800                          ERR_R_INTERNAL_ERROR);
801                 return EXT_RETURN_FAIL;
802             }
803
804             psksess = SSL_SESSION_new();
805             if (psksess == NULL
806                     || !SSL_SESSION_set1_master_key(psksess, psk, psklen)
807                     || !SSL_SESSION_set_cipher(psksess, cipher)
808                     || !SSL_SESSION_set_protocol_version(psksess, TLS1_3_VERSION)) {
809                 SSLfatal(s, SSL_AD_INTERNAL_ERROR,
810                          SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
811                          ERR_R_INTERNAL_ERROR);
812                 OPENSSL_cleanse(psk, psklen);
813                 return EXT_RETURN_FAIL;
814             }
815             OPENSSL_cleanse(psk, psklen);
816         }
817     }
818
819     SSL_SESSION_free(s->psksession);
820     s->psksession = psksess;
821     if (psksess != NULL) {
822         OPENSSL_free(s->psksession_id);
823         s->psksession_id = OPENSSL_memdup(id, idlen);
824         if (s->psksession_id == NULL) {
825             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
826                      SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA, ERR_R_INTERNAL_ERROR);
827             return EXT_RETURN_FAIL;
828         }
829         s->psksession_id_len = idlen;
830     }
831
832     if (s->early_data_state != SSL_EARLY_DATA_CONNECTING
833             || (s->session->ext.max_early_data == 0
834                 && (psksess == NULL || psksess->ext.max_early_data == 0))) {
835         s->max_early_data = 0;
836         return EXT_RETURN_NOT_SENT;
837     }
838     edsess = s->session->ext.max_early_data != 0 ? s->session : psksess;
839     s->max_early_data = edsess->ext.max_early_data;
840
841     if (edsess->ext.hostname != NULL) {
842         if (s->ext.hostname == NULL
843                 || (s->ext.hostname != NULL
844                     && strcmp(s->ext.hostname, edsess->ext.hostname) != 0)) {
845             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
846                      SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
847                      SSL_R_INCONSISTENT_EARLY_DATA_SNI);
848             return EXT_RETURN_FAIL;
849         }
850     }
851
852     if ((s->ext.alpn == NULL && edsess->ext.alpn_selected != NULL)) {
853         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
854                  SSL_R_INCONSISTENT_EARLY_DATA_ALPN);
855         return EXT_RETURN_FAIL;
856     }
857
858     /*
859      * Verify that we are offering an ALPN protocol consistent with the early
860      * data.
861      */
862     if (edsess->ext.alpn_selected != NULL) {
863         PACKET prots, alpnpkt;
864         int found = 0;
865
866         if (!PACKET_buf_init(&prots, s->ext.alpn, s->ext.alpn_len)) {
867             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
868                      SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA, ERR_R_INTERNAL_ERROR);
869             return EXT_RETURN_FAIL;
870         }
871         while (PACKET_get_length_prefixed_1(&prots, &alpnpkt)) {
872             if (PACKET_equal(&alpnpkt, edsess->ext.alpn_selected,
873                              edsess->ext.alpn_selected_len)) {
874                 found = 1;
875                 break;
876             }
877         }
878         if (!found) {
879             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
880                      SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
881                      SSL_R_INCONSISTENT_EARLY_DATA_ALPN);
882             return EXT_RETURN_FAIL;
883         }
884     }
885
886     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_early_data)
887             || !WPACKET_start_sub_packet_u16(pkt)
888             || !WPACKET_close(pkt)) {
889         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_EARLY_DATA,
890                  ERR_R_INTERNAL_ERROR);
891         return EXT_RETURN_FAIL;
892     }
893
894     /*
895      * We set this to rejected here. Later, if the server acknowledges the
896      * extension, we set it to accepted.
897      */
898     s->ext.early_data = SSL_EARLY_DATA_REJECTED;
899     s->ext.early_data_ok = 1;
900
901     return EXT_RETURN_SENT;
902 }
903
904 #define F5_WORKAROUND_MIN_MSG_LEN   0xff
905 #define F5_WORKAROUND_MAX_MSG_LEN   0x200
906
907 /*
908  * PSK pre binder overhead =
909  *  2 bytes for TLSEXT_TYPE_psk
910  *  2 bytes for extension length
911  *  2 bytes for identities list length
912  *  2 bytes for identity length
913  *  4 bytes for obfuscated_ticket_age
914  *  2 bytes for binder list length
915  *  1 byte for binder length
916  * The above excludes the number of bytes for the identity itself and the
917  * subsequent binder bytes
918  */
919 #define PSK_PRE_BINDER_OVERHEAD (2 + 2 + 2 + 2 + 4 + 2 + 1)
920
921 EXT_RETURN tls_construct_ctos_padding(SSL *s, WPACKET *pkt,
922                                       unsigned int context, X509 *x,
923                                       size_t chainidx)
924 {
925     unsigned char *padbytes;
926     size_t hlen;
927
928     if ((s->options & SSL_OP_TLSEXT_PADDING) == 0)
929         return EXT_RETURN_NOT_SENT;
930
931     /*
932      * Add padding to workaround bugs in F5 terminators. See RFC7685.
933      * This code calculates the length of all extensions added so far but
934      * excludes the PSK extension (because that MUST be written last). Therefore
935      * this extension MUST always appear second to last.
936      */
937     if (!WPACKET_get_total_written(pkt, &hlen)) {
938         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PADDING,
939                  ERR_R_INTERNAL_ERROR);
940         return EXT_RETURN_FAIL;
941     }
942
943     /*
944      * If we're going to send a PSK then that will be written out after this
945      * extension, so we need to calculate how long it is going to be.
946      */
947     if (s->session->ssl_version == TLS1_3_VERSION
948             && s->session->ext.ticklen != 0
949             && s->session->cipher != NULL) {
950         const EVP_MD *md = ssl_md(s->session->cipher->algorithm2);
951
952         if (md != NULL) {
953             /*
954              * Add the fixed PSK overhead, the identity length and the binder
955              * length.
956              */
957             hlen +=  PSK_PRE_BINDER_OVERHEAD + s->session->ext.ticklen
958                      + EVP_MD_size(md);
959         }
960     }
961
962     if (hlen > F5_WORKAROUND_MIN_MSG_LEN && hlen < F5_WORKAROUND_MAX_MSG_LEN) {
963         /* Calculate the amount of padding we need to add */
964         hlen = F5_WORKAROUND_MAX_MSG_LEN - hlen;
965
966         /*
967          * Take off the size of extension header itself (2 bytes for type and
968          * 2 bytes for length bytes), but ensure that the extension is at least
969          * 1 byte long so as not to have an empty extension last (WebSphere 7.x,
970          * 8.x are intolerant of that condition)
971          */
972         if (hlen > 4)
973             hlen -= 4;
974         else
975             hlen = 1;
976
977         if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_padding)
978                 || !WPACKET_sub_allocate_bytes_u16(pkt, hlen, &padbytes)) {
979             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PADDING,
980                      ERR_R_INTERNAL_ERROR);
981             return EXT_RETURN_FAIL;
982         }
983         memset(padbytes, 0, hlen);
984     }
985
986     return EXT_RETURN_SENT;
987 }
988
989 /*
990  * Construct the pre_shared_key extension
991  */
992 EXT_RETURN tls_construct_ctos_psk(SSL *s, WPACKET *pkt, unsigned int context,
993                                   X509 *x, size_t chainidx)
994 {
995 #ifndef OPENSSL_NO_TLS1_3
996     uint32_t now, agesec, agems = 0;
997     size_t reshashsize = 0, pskhashsize = 0, binderoffset, msglen;
998     unsigned char *resbinder = NULL, *pskbinder = NULL, *msgstart = NULL;
999     const EVP_MD *handmd = NULL, *mdres = NULL, *mdpsk = NULL;
1000     int dores = 0;
1001
1002     s->session->ext.tick_identity = TLSEXT_PSK_BAD_IDENTITY;
1003
1004     /*
1005      * Note: At this stage of the code we only support adding a single
1006      * resumption PSK. If we add support for multiple PSKs then the length
1007      * calculations in the padding extension will need to be adjusted.
1008      */
1009
1010     /*
1011      * If this is an incompatible or new session then we have nothing to resume
1012      * so don't add this extension.
1013      */
1014     if (s->session->ssl_version != TLS1_3_VERSION
1015             || (s->session->ext.ticklen == 0 && s->psksession == NULL))
1016         return EXT_RETURN_NOT_SENT;
1017
1018     if (s->hello_retry_request == SSL_HRR_PENDING)
1019         handmd = ssl_handshake_md(s);
1020
1021     if (s->session->ext.ticklen != 0) {
1022         /* Get the digest associated with the ciphersuite in the session */
1023         if (s->session->cipher == NULL) {
1024             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1025                      ERR_R_INTERNAL_ERROR);
1026             return EXT_RETURN_FAIL;
1027         }
1028         mdres = ssl_md(s->session->cipher->algorithm2);
1029         if (mdres == NULL) {
1030             /*
1031              * Don't recognize this cipher so we can't use the session.
1032              * Ignore it
1033              */
1034             goto dopsksess;
1035         }
1036
1037         if (s->hello_retry_request == SSL_HRR_PENDING && mdres != handmd) {
1038             /*
1039              * Selected ciphersuite hash does not match the hash for the session
1040              * so we can't use it.
1041              */
1042             goto dopsksess;
1043         }
1044
1045         /*
1046          * Technically the C standard just says time() returns a time_t and says
1047          * nothing about the encoding of that type. In practice most
1048          * implementations follow POSIX which holds it as an integral type in
1049          * seconds since epoch. We've already made the assumption that we can do
1050          * this in multiple places in the code, so portability shouldn't be an
1051          * issue.
1052          */
1053         now = (uint32_t)time(NULL);
1054         agesec = now - (uint32_t)s->session->time;
1055         /*
1056          * We calculate the age in seconds but the server may work in ms. Due to
1057          * rounding errors we could overestimate the age by up to 1s. It is
1058          * better to underestimate it. Otherwise, if the RTT is very short, when
1059          * the server calculates the age reported by the client it could be
1060          * bigger than the age calculated on the server - which should never
1061          * happen.
1062          */
1063         if (agesec > 0)
1064             agesec--;
1065
1066         if (s->session->ext.tick_lifetime_hint < agesec) {
1067             /* Ticket is too old. Ignore it. */
1068             goto dopsksess;
1069         }
1070
1071         /*
1072          * Calculate age in ms. We're just doing it to nearest second. Should be
1073          * good enough.
1074          */
1075         agems = agesec * (uint32_t)1000;
1076
1077         if (agesec != 0 && agems / (uint32_t)1000 != agesec) {
1078             /*
1079              * Overflow. Shouldn't happen unless this is a *really* old session.
1080              * If so we just ignore it.
1081              */
1082             goto dopsksess;
1083         }
1084
1085         /*
1086          * Obfuscate the age. Overflow here is fine, this addition is supposed
1087          * to be mod 2^32.
1088          */
1089         agems += s->session->ext.tick_age_add;
1090
1091         reshashsize = EVP_MD_size(mdres);
1092         dores = 1;
1093     }
1094
1095  dopsksess:
1096     if (!dores && s->psksession == NULL)
1097         return EXT_RETURN_NOT_SENT;
1098
1099     if (s->psksession != NULL) {
1100         mdpsk = ssl_md(s->psksession->cipher->algorithm2);
1101         if (mdpsk == NULL) {
1102             /*
1103              * Don't recognize this cipher so we can't use the session.
1104              * If this happens it's an application bug.
1105              */
1106             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1107                      SSL_R_BAD_PSK);
1108             return EXT_RETURN_FAIL;
1109         }
1110
1111         if (s->hello_retry_request == SSL_HRR_PENDING && mdpsk != handmd) {
1112             /*
1113              * Selected ciphersuite hash does not match the hash for the PSK
1114              * session. This is an application bug.
1115              */
1116             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1117                      SSL_R_BAD_PSK);
1118             return EXT_RETURN_FAIL;
1119         }
1120
1121         pskhashsize = EVP_MD_size(mdpsk);
1122     }
1123
1124     /* Create the extension, but skip over the binder for now */
1125     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_psk)
1126             || !WPACKET_start_sub_packet_u16(pkt)
1127             || !WPACKET_start_sub_packet_u16(pkt)) {
1128         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1129                  ERR_R_INTERNAL_ERROR);
1130         return EXT_RETURN_FAIL;
1131     }
1132
1133     if (dores) {
1134         if (!WPACKET_sub_memcpy_u16(pkt, s->session->ext.tick,
1135                                            s->session->ext.ticklen)
1136                 || !WPACKET_put_bytes_u32(pkt, agems)) {
1137             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1138                      ERR_R_INTERNAL_ERROR);
1139             return EXT_RETURN_FAIL;
1140         }
1141     }
1142
1143     if (s->psksession != NULL) {
1144         if (!WPACKET_sub_memcpy_u16(pkt, s->psksession_id,
1145                                     s->psksession_id_len)
1146                 || !WPACKET_put_bytes_u32(pkt, 0)) {
1147             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1148                      ERR_R_INTERNAL_ERROR);
1149             return EXT_RETURN_FAIL;
1150         }
1151     }
1152
1153     if (!WPACKET_close(pkt)
1154             || !WPACKET_get_total_written(pkt, &binderoffset)
1155             || !WPACKET_start_sub_packet_u16(pkt)
1156             || (dores
1157                 && !WPACKET_sub_allocate_bytes_u8(pkt, reshashsize, &resbinder))
1158             || (s->psksession != NULL
1159                 && !WPACKET_sub_allocate_bytes_u8(pkt, pskhashsize, &pskbinder))
1160             || !WPACKET_close(pkt)
1161             || !WPACKET_close(pkt)
1162             || !WPACKET_get_total_written(pkt, &msglen)
1163                /*
1164                 * We need to fill in all the sub-packet lengths now so we can
1165                 * calculate the HMAC of the message up to the binders
1166                 */
1167             || !WPACKET_fill_lengths(pkt)) {
1168         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_CONSTRUCT_CTOS_PSK,
1169                  ERR_R_INTERNAL_ERROR);
1170         return EXT_RETURN_FAIL;
1171     }
1172
1173     msgstart = WPACKET_get_curr(pkt) - msglen;
1174
1175     if (dores
1176             && tls_psk_do_binder(s, mdres, msgstart, binderoffset, NULL,
1177                                  resbinder, s->session, 1, 0) != 1) {
1178         /* SSLfatal() already called */
1179         return EXT_RETURN_FAIL;
1180     }
1181
1182     if (s->psksession != NULL
1183             && tls_psk_do_binder(s, mdpsk, msgstart, binderoffset, NULL,
1184                                  pskbinder, s->psksession, 1, 1) != 1) {
1185         /* SSLfatal() already called */
1186         return EXT_RETURN_FAIL;
1187     }
1188
1189     if (dores)
1190         s->session->ext.tick_identity = 0;
1191     if (s->psksession != NULL)
1192         s->psksession->ext.tick_identity = (dores ? 1 : 0);
1193
1194     return EXT_RETURN_SENT;
1195 #else
1196     return EXT_RETURN_NOT_SENT;
1197 #endif
1198 }
1199
1200 EXT_RETURN tls_construct_ctos_post_handshake_auth(SSL *s, WPACKET *pkt,
1201                                                   unsigned int context,
1202                                                   X509 *x, size_t chainidx)
1203 {
1204 #ifndef OPENSSL_NO_TLS1_3
1205     if (!s->pha_forced) {
1206         int i, n = 0;
1207
1208         /* check for cert, if present, we can do post-handshake auth */
1209         if (s->cert == NULL)
1210             return EXT_RETURN_NOT_SENT;
1211
1212         for (i = 0; i < SSL_PKEY_NUM; i++) {
1213             if (s->cert->pkeys[i].x509 != NULL
1214                     && s->cert->pkeys[i].privatekey != NULL)
1215                 n++;
1216         }
1217
1218         /* no identity certificates, so no extension */
1219         if (n == 0)
1220             return EXT_RETURN_NOT_SENT;
1221     }
1222
1223     /* construct extension - 0 length, no contents */
1224     if (!WPACKET_put_bytes_u16(pkt, TLSEXT_TYPE_post_handshake_auth)
1225             || !WPACKET_start_sub_packet_u16(pkt)
1226             || !WPACKET_close(pkt)) {
1227         SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1228                  SSL_F_TLS_CONSTRUCT_CTOS_POST_HANDSHAKE_AUTH,
1229                  ERR_R_INTERNAL_ERROR);
1230         return EXT_RETURN_FAIL;
1231     }
1232
1233     s->post_handshake_auth = SSL_PHA_EXT_SENT;
1234
1235     return EXT_RETURN_SENT;
1236 #else
1237     return EXT_RETURN_NOT_SENT;
1238 #endif
1239 }
1240
1241
1242 /*
1243  * Parse the server's renegotiation binding and abort if it's not right
1244  */
1245 int tls_parse_stoc_renegotiate(SSL *s, PACKET *pkt, unsigned int context,
1246                                X509 *x, size_t chainidx)
1247 {
1248     size_t expected_len = s->s3->previous_client_finished_len
1249         + s->s3->previous_server_finished_len;
1250     size_t ilen;
1251     const unsigned char *data;
1252
1253     /* Check for logic errors */
1254     if (!ossl_assert(expected_len == 0
1255                      || s->s3->previous_client_finished_len != 0)
1256         || !ossl_assert(expected_len == 0
1257                         || s->s3->previous_server_finished_len != 0)) {
1258         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1259                  ERR_R_INTERNAL_ERROR);
1260         return 0;
1261     }
1262
1263     /* Parse the length byte */
1264     if (!PACKET_get_1_len(pkt, &ilen)) {
1265         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1266                  SSL_R_RENEGOTIATION_ENCODING_ERR);
1267         return 0;
1268     }
1269
1270     /* Consistency check */
1271     if (PACKET_remaining(pkt) != ilen) {
1272         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1273                  SSL_R_RENEGOTIATION_ENCODING_ERR);
1274         return 0;
1275     }
1276
1277     /* Check that the extension matches */
1278     if (ilen != expected_len) {
1279         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1280                  SSL_R_RENEGOTIATION_MISMATCH);
1281         return 0;
1282     }
1283
1284     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_client_finished_len)
1285         || memcmp(data, s->s3->previous_client_finished,
1286                   s->s3->previous_client_finished_len) != 0) {
1287         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1288                  SSL_R_RENEGOTIATION_MISMATCH);
1289         return 0;
1290     }
1291
1292     if (!PACKET_get_bytes(pkt, &data, s->s3->previous_server_finished_len)
1293         || memcmp(data, s->s3->previous_server_finished,
1294                   s->s3->previous_server_finished_len) != 0) {
1295         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_RENEGOTIATE,
1296                  SSL_R_RENEGOTIATION_MISMATCH);
1297         return 0;
1298     }
1299     s->s3->send_connection_binding = 1;
1300
1301     return 1;
1302 }
1303
1304 /* Parse the server's max fragment len extension packet */
1305 int tls_parse_stoc_maxfragmentlen(SSL *s, PACKET *pkt, unsigned int context,
1306                                   X509 *x, size_t chainidx)
1307 {
1308     unsigned int value;
1309
1310     if (PACKET_remaining(pkt) != 1 || !PACKET_get_1(pkt, &value)) {
1311         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN,
1312                  SSL_R_BAD_EXTENSION);
1313         return 0;
1314     }
1315
1316     /* |value| should contains a valid max-fragment-length code. */
1317     if (!IS_MAX_FRAGMENT_LENGTH_EXT_VALID(value)) {
1318         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1319                  SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN,
1320                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
1321         return 0;
1322     }
1323
1324     /* Must be the same value as client-configured one who was sent to server */
1325     /*-
1326      * RFC 6066: if a client receives a maximum fragment length negotiation
1327      * response that differs from the length it requested, ...
1328      * It must abort with SSL_AD_ILLEGAL_PARAMETER alert
1329      */
1330     if (value != s->ext.max_fragment_len_mode) {
1331         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1332                  SSL_F_TLS_PARSE_STOC_MAXFRAGMENTLEN,
1333                  SSL_R_SSL3_EXT_INVALID_MAX_FRAGMENT_LENGTH);
1334         return 0;
1335     }
1336
1337     /*
1338      * Maximum Fragment Length Negotiation succeeded.
1339      * The negotiated Maximum Fragment Length is binding now.
1340      */
1341     s->session->ext.max_fragment_len_mode = value;
1342
1343     return 1;
1344 }
1345
1346 int tls_parse_stoc_server_name(SSL *s, PACKET *pkt, unsigned int context,
1347                                X509 *x, size_t chainidx)
1348 {
1349     if (s->ext.hostname == NULL) {
1350         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_SERVER_NAME,
1351                  ERR_R_INTERNAL_ERROR);
1352         return 0;
1353     }
1354
1355     if (PACKET_remaining(pkt) > 0) {
1356         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_SERVER_NAME,
1357                  SSL_R_BAD_EXTENSION);
1358         return 0;
1359     }
1360
1361     if (!s->hit) {
1362         if (s->session->ext.hostname != NULL) {
1363             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_SERVER_NAME,
1364                      ERR_R_INTERNAL_ERROR);
1365             return 0;
1366         }
1367         s->session->ext.hostname = OPENSSL_strdup(s->ext.hostname);
1368         if (s->session->ext.hostname == NULL) {
1369             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_SERVER_NAME,
1370                      ERR_R_INTERNAL_ERROR);
1371             return 0;
1372         }
1373     }
1374
1375     return 1;
1376 }
1377
1378 #ifndef OPENSSL_NO_EC
1379 int tls_parse_stoc_ec_pt_formats(SSL *s, PACKET *pkt, unsigned int context,
1380                                  X509 *x, size_t chainidx)
1381 {
1382     size_t ecpointformats_len;
1383     PACKET ecptformatlist;
1384
1385     if (!PACKET_as_length_prefixed_1(pkt, &ecptformatlist)) {
1386         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS,
1387                  SSL_R_BAD_EXTENSION);
1388         return 0;
1389     }
1390     if (!s->hit) {
1391         ecpointformats_len = PACKET_remaining(&ecptformatlist);
1392         if (ecpointformats_len == 0) {
1393             SSLfatal(s, SSL_AD_DECODE_ERROR,
1394                      SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS, SSL_R_BAD_LENGTH);
1395             return 0;
1396         }
1397
1398         s->session->ext.ecpointformats_len = 0;
1399         OPENSSL_free(s->session->ext.ecpointformats);
1400         s->session->ext.ecpointformats = OPENSSL_malloc(ecpointformats_len);
1401         if (s->session->ext.ecpointformats == NULL) {
1402             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1403                      SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
1404             return 0;
1405         }
1406
1407         s->session->ext.ecpointformats_len = ecpointformats_len;
1408
1409         if (!PACKET_copy_bytes(&ecptformatlist,
1410                                s->session->ext.ecpointformats,
1411                                ecpointformats_len)) {
1412             SSLfatal(s, SSL_AD_INTERNAL_ERROR,
1413                      SSL_F_TLS_PARSE_STOC_EC_PT_FORMATS, ERR_R_INTERNAL_ERROR);
1414             return 0;
1415         }
1416     }
1417
1418     return 1;
1419 }
1420 #endif
1421
1422 int tls_parse_stoc_session_ticket(SSL *s, PACKET *pkt, unsigned int context,
1423                                   X509 *x, size_t chainidx)
1424 {
1425     if (s->ext.session_ticket_cb != NULL &&
1426         !s->ext.session_ticket_cb(s, PACKET_data(pkt),
1427                               PACKET_remaining(pkt),
1428                               s->ext.session_ticket_cb_arg)) {
1429         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE,
1430                  SSL_F_TLS_PARSE_STOC_SESSION_TICKET, SSL_R_BAD_EXTENSION);
1431         return 0;
1432     }
1433
1434     if (!tls_use_ticket(s)) {
1435         SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION,
1436                  SSL_F_TLS_PARSE_STOC_SESSION_TICKET, SSL_R_BAD_EXTENSION);
1437         return 0;
1438     }
1439     if (PACKET_remaining(pkt) > 0) {
1440         SSLfatal(s, SSL_AD_DECODE_ERROR,
1441                  SSL_F_TLS_PARSE_STOC_SESSION_TICKET, SSL_R_BAD_EXTENSION);
1442         return 0;
1443     }
1444
1445     s->ext.ticket_expected = 1;
1446
1447     return 1;
1448 }
1449
1450 #ifndef OPENSSL_NO_OCSP
1451 int tls_parse_stoc_status_request(SSL *s, PACKET *pkt, unsigned int context,
1452                                   X509 *x, size_t chainidx)
1453 {
1454     if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
1455         /* We ignore this if the server sends a CertificateRequest */
1456         /* TODO(TLS1.3): Add support for this */
1457         return 1;
1458     }
1459
1460     /*
1461      * MUST only be sent if we've requested a status
1462      * request message. In TLS <= 1.2 it must also be empty.
1463      */
1464     if (s->ext.status_type != TLSEXT_STATUSTYPE_ocsp) {
1465         SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION,
1466                  SSL_F_TLS_PARSE_STOC_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
1467         return 0;
1468     }
1469     if (!SSL_IS_TLS13(s) && PACKET_remaining(pkt) > 0) {
1470         SSLfatal(s, SSL_AD_DECODE_ERROR,
1471                  SSL_F_TLS_PARSE_STOC_STATUS_REQUEST, SSL_R_BAD_EXTENSION);
1472         return 0;
1473     }
1474
1475     if (SSL_IS_TLS13(s)) {
1476         /* We only know how to handle this if it's for the first Certificate in
1477          * the chain. We ignore any other responses.
1478          */
1479         if (chainidx != 0)
1480             return 1;
1481
1482         /* SSLfatal() already called */
1483         return tls_process_cert_status_body(s, pkt);
1484     }
1485
1486     /* Set flag to expect CertificateStatus message */
1487     s->ext.status_expected = 1;
1488
1489     return 1;
1490 }
1491 #endif
1492
1493
1494 #ifndef OPENSSL_NO_CT
1495 int tls_parse_stoc_sct(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1496                        size_t chainidx)
1497 {
1498     if (context == SSL_EXT_TLS1_3_CERTIFICATE_REQUEST) {
1499         /* We ignore this if the server sends it in a CertificateRequest */
1500         /* TODO(TLS1.3): Add support for this */
1501         return 1;
1502     }
1503
1504     /*
1505      * Only take it if we asked for it - i.e if there is no CT validation
1506      * callback set, then a custom extension MAY be processing it, so we
1507      * need to let control continue to flow to that.
1508      */
1509     if (s->ct_validation_callback != NULL) {
1510         size_t size = PACKET_remaining(pkt);
1511
1512         /* Simply copy it off for later processing */
1513         OPENSSL_free(s->ext.scts);
1514         s->ext.scts = NULL;
1515
1516         s->ext.scts_len = (uint16_t)size;
1517         if (size > 0) {
1518             s->ext.scts = OPENSSL_malloc(size);
1519             if (s->ext.scts == NULL
1520                     || !PACKET_copy_bytes(pkt, s->ext.scts, size)) {
1521                 SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_SCT,
1522                          ERR_R_INTERNAL_ERROR);
1523                 return 0;
1524             }
1525         }
1526     } else {
1527         ENDPOINT role = (context & SSL_EXT_TLS1_2_SERVER_HELLO) != 0
1528                         ? ENDPOINT_CLIENT : ENDPOINT_BOTH;
1529
1530         /*
1531          * If we didn't ask for it then there must be a custom extension,
1532          * otherwise this is unsolicited.
1533          */
1534         if (custom_ext_find(&s->cert->custext, role,
1535                             TLSEXT_TYPE_signed_certificate_timestamp,
1536                             NULL) == NULL) {
1537             SSLfatal(s, TLS1_AD_UNSUPPORTED_EXTENSION, SSL_F_TLS_PARSE_STOC_SCT,
1538                      SSL_R_BAD_EXTENSION);
1539             return 0;
1540         }
1541
1542         if (!custom_ext_parse(s, context,
1543                              TLSEXT_TYPE_signed_certificate_timestamp,
1544                              PACKET_data(pkt), PACKET_remaining(pkt),
1545                              x, chainidx)) {
1546             /* SSLfatal already called */
1547             return 0;
1548         }
1549     }
1550
1551     return 1;
1552 }
1553 #endif
1554
1555
1556 #ifndef OPENSSL_NO_NEXTPROTONEG
1557 /*
1558  * ssl_next_proto_validate validates a Next Protocol Negotiation block. No
1559  * elements of zero length are allowed and the set of elements must exactly
1560  * fill the length of the block. Returns 1 on success or 0 on failure.
1561  */
1562 static int ssl_next_proto_validate(SSL *s, PACKET *pkt)
1563 {
1564     PACKET tmp_protocol;
1565
1566     while (PACKET_remaining(pkt)) {
1567         if (!PACKET_get_length_prefixed_1(pkt, &tmp_protocol)
1568             || PACKET_remaining(&tmp_protocol) == 0) {
1569             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_SSL_NEXT_PROTO_VALIDATE,
1570                      SSL_R_BAD_EXTENSION);
1571             return 0;
1572         }
1573     }
1574
1575     return 1;
1576 }
1577
1578 int tls_parse_stoc_npn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1579                        size_t chainidx)
1580 {
1581     unsigned char *selected;
1582     unsigned char selected_len;
1583     PACKET tmppkt;
1584
1585     /* Check if we are in a renegotiation. If so ignore this extension */
1586     if (!SSL_IS_FIRST_HANDSHAKE(s))
1587         return 1;
1588
1589     /* We must have requested it. */
1590     if (s->ctx->ext.npn_select_cb == NULL) {
1591         SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_F_TLS_PARSE_STOC_NPN,
1592                  SSL_R_BAD_EXTENSION);
1593         return 0;
1594     }
1595
1596     /* The data must be valid */
1597     tmppkt = *pkt;
1598     if (!ssl_next_proto_validate(s, &tmppkt)) {
1599         /* SSLfatal() already called */
1600         return 0;
1601     }
1602     if (s->ctx->ext.npn_select_cb(s, &selected, &selected_len,
1603                                   PACKET_data(pkt),
1604                                   PACKET_remaining(pkt),
1605                                   s->ctx->ext.npn_select_cb_arg) !=
1606              SSL_TLSEXT_ERR_OK) {
1607         SSLfatal(s, SSL_AD_HANDSHAKE_FAILURE, SSL_F_TLS_PARSE_STOC_NPN,
1608                  SSL_R_BAD_EXTENSION);
1609         return 0;
1610     }
1611
1612     /*
1613      * Could be non-NULL if server has sent multiple NPN extensions in
1614      * a single Serverhello
1615      */
1616     OPENSSL_free(s->ext.npn);
1617     s->ext.npn = OPENSSL_malloc(selected_len);
1618     if (s->ext.npn == NULL) {
1619         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_NPN,
1620                  ERR_R_INTERNAL_ERROR);
1621         return 0;
1622     }
1623
1624     memcpy(s->ext.npn, selected, selected_len);
1625     s->ext.npn_len = selected_len;
1626     s->s3->npn_seen = 1;
1627
1628     return 1;
1629 }
1630 #endif
1631
1632 int tls_parse_stoc_alpn(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1633                         size_t chainidx)
1634 {
1635     size_t len;
1636
1637     /* We must have requested it. */
1638     if (!s->s3->alpn_sent) {
1639         SSLfatal(s, SSL_AD_UNSUPPORTED_EXTENSION, SSL_F_TLS_PARSE_STOC_ALPN,
1640                  SSL_R_BAD_EXTENSION);
1641         return 0;
1642     }
1643     /*-
1644      * The extension data consists of:
1645      *   uint16 list_length
1646      *   uint8 proto_length;
1647      *   uint8 proto[proto_length];
1648      */
1649     if (!PACKET_get_net_2_len(pkt, &len)
1650         || PACKET_remaining(pkt) != len || !PACKET_get_1_len(pkt, &len)
1651         || PACKET_remaining(pkt) != len) {
1652         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_ALPN,
1653                  SSL_R_BAD_EXTENSION);
1654         return 0;
1655     }
1656     OPENSSL_free(s->s3->alpn_selected);
1657     s->s3->alpn_selected = OPENSSL_malloc(len);
1658     if (s->s3->alpn_selected == NULL) {
1659         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_ALPN,
1660                  ERR_R_INTERNAL_ERROR);
1661         return 0;
1662     }
1663     if (!PACKET_copy_bytes(pkt, s->s3->alpn_selected, len)) {
1664         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_ALPN,
1665                  SSL_R_BAD_EXTENSION);
1666         return 0;
1667     }
1668     s->s3->alpn_selected_len = len;
1669
1670     if (s->session->ext.alpn_selected == NULL
1671             || s->session->ext.alpn_selected_len != len
1672             || memcmp(s->session->ext.alpn_selected, s->s3->alpn_selected, len)
1673                != 0) {
1674         /* ALPN not consistent with the old session so cannot use early_data */
1675         s->ext.early_data_ok = 0;
1676     }
1677     if (!s->hit) {
1678         /* If a new session then update it with the selected ALPN */
1679         s->session->ext.alpn_selected =
1680             OPENSSL_memdup(s->s3->alpn_selected, s->s3->alpn_selected_len);
1681         if (s->session->ext.alpn_selected == NULL) {
1682             SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_ALPN,
1683                      ERR_R_INTERNAL_ERROR);
1684             return 0;
1685         }
1686         s->session->ext.alpn_selected_len = s->s3->alpn_selected_len;
1687     }
1688
1689     return 1;
1690 }
1691
1692 #ifndef OPENSSL_NO_SRTP
1693 int tls_parse_stoc_use_srtp(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1694                             size_t chainidx)
1695 {
1696     unsigned int id, ct, mki;
1697     int i;
1698     STACK_OF(SRTP_PROTECTION_PROFILE) *clnt;
1699     SRTP_PROTECTION_PROFILE *prof;
1700
1701     if (!PACKET_get_net_2(pkt, &ct) || ct != 2
1702             || !PACKET_get_net_2(pkt, &id)
1703             || !PACKET_get_1(pkt, &mki)
1704             || PACKET_remaining(pkt) != 0) {
1705         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_USE_SRTP,
1706                  SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
1707         return 0;
1708     }
1709
1710     if (mki != 0) {
1711         /* Must be no MKI, since we never offer one */
1712         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_USE_SRTP,
1713                  SSL_R_BAD_SRTP_MKI_VALUE);
1714         return 0;
1715     }
1716
1717     /* Throw an error if the server gave us an unsolicited extension */
1718     clnt = SSL_get_srtp_profiles(s);
1719     if (clnt == NULL) {
1720         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_USE_SRTP,
1721                  SSL_R_NO_SRTP_PROFILES);
1722         return 0;
1723     }
1724
1725     /*
1726      * Check to see if the server gave us something we support (and
1727      * presumably offered)
1728      */
1729     for (i = 0; i < sk_SRTP_PROTECTION_PROFILE_num(clnt); i++) {
1730         prof = sk_SRTP_PROTECTION_PROFILE_value(clnt, i);
1731
1732         if (prof->id == id) {
1733             s->srtp_profile = prof;
1734             return 1;
1735         }
1736     }
1737
1738     SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_USE_SRTP,
1739              SSL_R_BAD_SRTP_PROTECTION_PROFILE_LIST);
1740     return 0;
1741 }
1742 #endif
1743
1744 int tls_parse_stoc_etm(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1745                        size_t chainidx)
1746 {
1747     /* Ignore if inappropriate ciphersuite */
1748     if (!(s->options & SSL_OP_NO_ENCRYPT_THEN_MAC)
1749             && s->s3->tmp.new_cipher->algorithm_mac != SSL_AEAD
1750             && s->s3->tmp.new_cipher->algorithm_enc != SSL_RC4)
1751         s->ext.use_etm = 1;
1752
1753     return 1;
1754 }
1755
1756 int tls_parse_stoc_ems(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1757                        size_t chainidx)
1758 {
1759     s->s3->flags |= TLS1_FLAGS_RECEIVED_EXTMS;
1760     if (!s->hit)
1761         s->session->flags |= SSL_SESS_FLAG_EXTMS;
1762
1763     return 1;
1764 }
1765
1766 int tls_parse_stoc_supported_versions(SSL *s, PACKET *pkt, unsigned int context,
1767                                       X509 *x, size_t chainidx)
1768 {
1769     unsigned int version;
1770
1771     if (!PACKET_get_net_2(pkt, &version)
1772             || PACKET_remaining(pkt) != 0) {
1773         SSLfatal(s, SSL_AD_DECODE_ERROR,
1774                  SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS,
1775                  SSL_R_LENGTH_MISMATCH);
1776         return 0;
1777     }
1778
1779     /* TODO(TLS1.3): Remove this before release */
1780     if (version == TLS1_3_VERSION_DRAFT)
1781         version = TLS1_3_VERSION;
1782
1783     /*
1784      * The only protocol version we support which is valid in this extension in
1785      * a ServerHello is TLSv1.3 therefore we shouldn't be getting anything else.
1786      */
1787     if (version != TLS1_3_VERSION) {
1788         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1789                  SSL_F_TLS_PARSE_STOC_SUPPORTED_VERSIONS,
1790                  SSL_R_BAD_PROTOCOL_VERSION_NUMBER);
1791         return 0;
1792     }
1793
1794     /* We ignore this extension for HRRs except to sanity check it */
1795     if (context == SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST)
1796         return 1;
1797
1798     /* We just set it here. We validate it in ssl_choose_client_version */
1799     s->version = version;
1800
1801     return 1;
1802 }
1803
1804 int tls_parse_stoc_key_share(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1805                              size_t chainidx)
1806 {
1807 #ifndef OPENSSL_NO_TLS1_3
1808     unsigned int group_id;
1809     PACKET encoded_pt;
1810     EVP_PKEY *ckey = s->s3->tmp.pkey, *skey = NULL;
1811
1812     /* Sanity check */
1813     if (ckey == NULL || s->s3->peer_tmp != NULL) {
1814         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1815                  ERR_R_INTERNAL_ERROR);
1816         return 0;
1817     }
1818
1819     if (!PACKET_get_net_2(pkt, &group_id)) {
1820         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1821                  SSL_R_LENGTH_MISMATCH);
1822         return 0;
1823     }
1824
1825     if ((context & SSL_EXT_TLS1_3_HELLO_RETRY_REQUEST) != 0) {
1826         const uint16_t *pgroups = NULL;
1827         size_t i, num_groups;
1828
1829         if (PACKET_remaining(pkt) != 0) {
1830             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1831                      SSL_R_LENGTH_MISMATCH);
1832             return 0;
1833         }
1834
1835         /*
1836          * It is an error if the HelloRetryRequest wants a key_share that we
1837          * already sent in the first ClientHello
1838          */
1839         if (group_id == s->s3->group_id) {
1840             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1841                      SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1842             return 0;
1843         }
1844
1845         /* Validate the selected group is one we support */
1846         tls1_get_supported_groups(s, &pgroups, &num_groups);
1847         for (i = 0; i < num_groups; i++) {
1848             if (group_id == pgroups[i])
1849                 break;
1850         }
1851         if (i >= num_groups
1852                 || !tls_curve_allowed(s, group_id, SSL_SECOP_CURVE_SUPPORTED)) {
1853             SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER,
1854                      SSL_F_TLS_PARSE_STOC_KEY_SHARE, SSL_R_BAD_KEY_SHARE);
1855             return 0;
1856         }
1857
1858         s->s3->group_id = group_id;
1859         EVP_PKEY_free(s->s3->tmp.pkey);
1860         s->s3->tmp.pkey = NULL;
1861         return 1;
1862     }
1863
1864     if (group_id != s->s3->group_id) {
1865         /*
1866          * This isn't for the group that we sent in the original
1867          * key_share!
1868          */
1869         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1870                  SSL_R_BAD_KEY_SHARE);
1871         return 0;
1872     }
1873
1874     if (!PACKET_as_length_prefixed_2(pkt, &encoded_pt)
1875             || PACKET_remaining(&encoded_pt) == 0) {
1876         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1877                  SSL_R_LENGTH_MISMATCH);
1878         return 0;
1879     }
1880
1881     skey = ssl_generate_pkey(ckey);
1882     if (skey == NULL) {
1883         SSLfatal(s, SSL_AD_INTERNAL_ERROR, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1884                  ERR_R_MALLOC_FAILURE);
1885         return 0;
1886     }
1887     if (!EVP_PKEY_set1_tls_encodedpoint(skey, PACKET_data(&encoded_pt),
1888                                         PACKET_remaining(&encoded_pt))) {
1889         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_KEY_SHARE,
1890                  SSL_R_BAD_ECPOINT);
1891         EVP_PKEY_free(skey);
1892         return 0;
1893     }
1894
1895     if (ssl_derive(s, ckey, skey, 1) == 0) {
1896         /* SSLfatal() already called */
1897         EVP_PKEY_free(skey);
1898         return 0;
1899     }
1900     s->s3->peer_tmp = skey;
1901 #endif
1902
1903     return 1;
1904 }
1905
1906 int tls_parse_stoc_cookie(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1907                        size_t chainidx)
1908 {
1909     PACKET cookie;
1910
1911     if (!PACKET_as_length_prefixed_2(pkt, &cookie)
1912             || !PACKET_memdup(&cookie, &s->ext.tls13_cookie,
1913                               &s->ext.tls13_cookie_len)) {
1914         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_COOKIE,
1915                  SSL_R_LENGTH_MISMATCH);
1916         return 0;
1917     }
1918
1919     return 1;
1920 }
1921
1922 int tls_parse_stoc_early_data(SSL *s, PACKET *pkt, unsigned int context,
1923                               X509 *x, size_t chainidx)
1924 {
1925     if (context == SSL_EXT_TLS1_3_NEW_SESSION_TICKET) {
1926         unsigned long max_early_data;
1927
1928         if (!PACKET_get_net_4(pkt, &max_early_data)
1929                 || PACKET_remaining(pkt) != 0) {
1930             SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_EARLY_DATA,
1931                      SSL_R_INVALID_MAX_EARLY_DATA);
1932             return 0;
1933         }
1934
1935         s->session->ext.max_early_data = max_early_data;
1936
1937         return 1;
1938     }
1939
1940     if (PACKET_remaining(pkt) != 0) {
1941         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_EARLY_DATA,
1942                  SSL_R_BAD_EXTENSION);
1943         return 0;
1944     }
1945
1946     if (!s->ext.early_data_ok
1947             || !s->hit
1948             || s->session->ext.tick_identity != 0) {
1949         /*
1950          * If we get here then we didn't send early data, or we didn't resume
1951          * using the first identity, or the SNI/ALPN is not consistent so the
1952          * server should not be accepting it.
1953          */
1954         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_EARLY_DATA,
1955                  SSL_R_BAD_EXTENSION);
1956         return 0;
1957     }
1958
1959     s->ext.early_data = SSL_EARLY_DATA_ACCEPTED;
1960
1961     return 1;
1962 }
1963
1964 int tls_parse_stoc_psk(SSL *s, PACKET *pkt, unsigned int context, X509 *x,
1965                        size_t chainidx)
1966 {
1967 #ifndef OPENSSL_NO_TLS1_3
1968     unsigned int identity;
1969
1970     if (!PACKET_get_net_2(pkt, &identity) || PACKET_remaining(pkt) != 0) {
1971         SSLfatal(s, SSL_AD_DECODE_ERROR, SSL_F_TLS_PARSE_STOC_PSK,
1972                  SSL_R_LENGTH_MISMATCH);
1973         return 0;
1974     }
1975
1976     if (s->session->ext.tick_identity == (int)identity) {
1977         s->hit = 1;
1978         SSL_SESSION_free(s->psksession);
1979         s->psksession = NULL;
1980         return 1;
1981     }
1982
1983     if (s->psksession == NULL
1984             || s->psksession->ext.tick_identity != (int)identity) {
1985         SSLfatal(s, SSL_AD_ILLEGAL_PARAMETER, SSL_F_TLS_PARSE_STOC_PSK,
1986                  SSL_R_BAD_PSK_IDENTITY);
1987         return 0;
1988     }
1989
1990     /*
1991      * If we used the external PSK for sending early_data then s->early_secret
1992      * is already set up, so don't overwrite it. Otherwise we copy the
1993      * early_secret across that we generated earlier.
1994      */
1995     if ((s->early_data_state != SSL_EARLY_DATA_WRITE_RETRY
1996                 && s->early_data_state != SSL_EARLY_DATA_FINISHED_WRITING)
1997             || s->session->ext.max_early_data > 0
1998             || s->psksession->ext.max_early_data == 0)
1999         memcpy(s->early_secret, s->psksession->early_secret, EVP_MAX_MD_SIZE);
2000
2001     SSL_SESSION_free(s->session);
2002     s->session = s->psksession;
2003     s->psksession = NULL;
2004     s->hit = 1;
2005 #endif
2006
2007     return 1;
2008 }