526318f791e502e16419ad82ffce3b1c4080700d
[openssl.git] / ssl / statem / extensions.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 "../ssl_locl.h"
11 #include "statem_locl.h"
12
13 static int final_renegotiate(SSL *s, unsigned int context, int sent,
14                                      int *al);
15 static int init_server_name(SSL *s, unsigned int context);
16 static int final_server_name(SSL *s, unsigned int context, int sent,
17                                      int *al);
18 #ifndef OPENSSL_NO_EC
19 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
20                                        int *al);
21 #endif
22 static int init_session_ticket(SSL *s, unsigned int context);
23 #ifndef OPENSSL_NO_OCSP
24 static int init_status_request(SSL *s, unsigned int context);
25 #endif
26 #ifndef OPENSSL_NO_NEXTPROTONEG
27 static int init_npn(SSL *s, unsigned int context);
28 #endif
29 static int init_alpn(SSL *s, unsigned int context);
30 static int final_alpn(SSL *s, unsigned int context, int sent, int *al);
31 static int init_sig_algs(SSL *s, unsigned int context);
32 #ifndef OPENSSL_NO_SRP
33 static int init_srp(SSL *s, unsigned int context);
34 #endif
35 static int init_etm(SSL *s, unsigned int context);
36 static int init_ems(SSL *s, unsigned int context);
37 static int final_ems(SSL *s, unsigned int context, int sent, int *al);
38 static int init_psk_kex_modes(SSL *s, unsigned int context);
39 static int final_key_share(SSL *s, unsigned int context, int sent, int *al);
40 #ifndef OPENSSL_NO_SRTP
41 static int init_srtp(SSL *s, unsigned int context);
42 #endif
43 static int final_sig_algs(SSL *s, unsigned int context, int sent, int *al);
44
45 /* Structure to define a built-in extension */
46 typedef struct extensions_definition_st {
47     /* The defined type for the extension */
48     unsigned int type;
49     /*
50      * The context that this extension applies to, e.g. what messages and
51      * protocol versions
52      */
53     unsigned int context;
54     /*
55      * Initialise extension before parsing. Always called for relevant contexts
56      * even if extension not present
57      */
58     int (*init)(SSL *s, unsigned int context);
59     /* Parse extension sent from client to server */
60     int (*parse_ctos)(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al);
61     /* Parse extension send from server to client */
62     int (*parse_stoc)(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al);
63     /* Construct extension sent from server to client */
64     int (*construct_stoc)(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
65                           int *al);
66     /* Construct extension sent from client to server */
67     int (*construct_ctos)(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
68                           int *al);
69     /*
70      * Finalise extension after parsing. Always called where an extensions was
71      * initialised even if the extension was not present. |sent| is set to 1 if
72      * the extension was seen, or 0 otherwise.
73      */
74     int (*final)(SSL *s, unsigned int context, int sent, int *al);
75 } EXTENSION_DEFINITION;
76
77 /*
78  * Definitions of all built-in extensions. NOTE: Changes in the number or order
79  * of these extensions should be mirrored with equivalent changes to the 
80  * indexes ( TLSEXT_IDX_* ) defined in ssl_locl.h.
81  * Each extension has an initialiser, a client and
82  * server side parser and a finaliser. The initialiser is called (if the
83  * extension is relevant to the given context) even if we did not see the
84  * extension in the message that we received. The parser functions are only
85  * called if we see the extension in the message. The finalisers are always
86  * called if the initialiser was called.
87  * There are also server and client side constructor functions which are always
88  * called during message construction if the extension is relevant for the
89  * given context.
90  * The initialisation, parsing, finalisation and construction functions are
91  * always called in the order defined in this list. Some extensions may depend
92  * on others having been processed first, so the order of this list is
93  * significant.
94  * The extension context is defined by a series of flags which specify which
95  * messages the extension is relevant to. These flags also specify whether the
96  * extension is relevant to a particular protocol or protocol version.
97  *
98  * TODO(TLS1.3): Make sure we have a test to check the consistency of these
99  */
100 #define INVALID_EXTENSION { 0x10000, 0, NULL, NULL, NULL, NULL, NULL, NULL }
101 static const EXTENSION_DEFINITION ext_defs[] = {
102     {
103         TLSEXT_TYPE_renegotiate,
104         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_SSL3_ALLOWED
105         | EXT_TLS1_2_AND_BELOW_ONLY,
106         NULL, tls_parse_ctos_renegotiate, tls_parse_stoc_renegotiate,
107         tls_construct_stoc_renegotiate, tls_construct_ctos_renegotiate,
108         final_renegotiate
109     },
110     {
111         TLSEXT_TYPE_server_name,
112         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
113         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
114         init_server_name,
115         tls_parse_ctos_server_name, tls_parse_stoc_server_name,
116         tls_construct_stoc_server_name, tls_construct_ctos_server_name,
117         final_server_name
118     },
119 #ifndef OPENSSL_NO_SRP
120     {
121         TLSEXT_TYPE_srp,
122         EXT_CLIENT_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
123         init_srp, tls_parse_ctos_srp, NULL, NULL, tls_construct_ctos_srp, NULL
124     },
125 #else
126     INVALID_EXTENSION,
127 #endif
128 #ifndef OPENSSL_NO_EC
129     {
130         TLSEXT_TYPE_ec_point_formats,
131         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
132         NULL, tls_parse_ctos_ec_pt_formats, tls_parse_stoc_ec_pt_formats,
133         tls_construct_stoc_ec_pt_formats, tls_construct_ctos_ec_pt_formats,
134         final_ec_pt_formats
135     },
136     {
137         TLSEXT_TYPE_supported_groups,
138         EXT_CLIENT_HELLO | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
139         NULL, tls_parse_ctos_supported_groups, NULL,
140         NULL /* TODO(TLS1.3): Need to add this */,
141         tls_construct_ctos_supported_groups, NULL
142     },
143 #else
144     INVALID_EXTENSION,
145     INVALID_EXTENSION,
146 #endif
147     {
148         TLSEXT_TYPE_session_ticket,
149         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
150         init_session_ticket, tls_parse_ctos_session_ticket,
151         tls_parse_stoc_session_ticket, tls_construct_stoc_session_ticket,
152         tls_construct_ctos_session_ticket, NULL
153     },
154     {
155         TLSEXT_TYPE_signature_algorithms,
156         EXT_CLIENT_HELLO,
157         init_sig_algs, tls_parse_ctos_sig_algs, NULL, NULL,
158         tls_construct_ctos_sig_algs, final_sig_algs
159     },
160 #ifndef OPENSSL_NO_OCSP
161     {
162         TLSEXT_TYPE_status_request,
163         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
164         | EXT_TLS1_3_CERTIFICATE,
165         init_status_request, tls_parse_ctos_status_request,
166         tls_parse_stoc_status_request, tls_construct_stoc_status_request,
167         tls_construct_ctos_status_request, NULL
168     },
169 #else
170     INVALID_EXTENSION,
171 #endif
172 #ifndef OPENSSL_NO_NEXTPROTONEG
173     {
174         TLSEXT_TYPE_next_proto_neg,
175         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
176         init_npn, tls_parse_ctos_npn, tls_parse_stoc_npn,
177         tls_construct_stoc_next_proto_neg, tls_construct_ctos_npn, NULL
178     },
179 #else
180     INVALID_EXTENSION,
181 #endif
182     {
183         /*
184          * Must appear in this list after server_name so that finalisation
185          * happens after server_name callbacks
186          */
187         TLSEXT_TYPE_application_layer_protocol_negotiation,
188         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
189         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS,
190         init_alpn, tls_parse_ctos_alpn, tls_parse_stoc_alpn,
191         tls_construct_stoc_alpn, tls_construct_ctos_alpn, final_alpn
192     },
193 #ifndef OPENSSL_NO_SRTP
194     {
195         TLSEXT_TYPE_use_srtp,
196         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
197         | EXT_TLS1_3_ENCRYPTED_EXTENSIONS | EXT_DTLS_ONLY,
198         init_srtp, tls_parse_ctos_use_srtp, tls_parse_stoc_use_srtp,
199         tls_construct_stoc_use_srtp, tls_construct_ctos_use_srtp, NULL
200     },
201 #else
202     INVALID_EXTENSION,
203 #endif
204     {
205         TLSEXT_TYPE_encrypt_then_mac,
206         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
207         init_etm, tls_parse_ctos_etm, tls_parse_stoc_etm,
208         tls_construct_stoc_etm, tls_construct_ctos_etm, NULL
209     },
210 #ifndef OPENSSL_NO_CT
211     {
212         TLSEXT_TYPE_signed_certificate_timestamp,
213         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO
214         | EXT_TLS1_3_CERTIFICATE,
215         NULL,
216         /*
217          * No server side support for this, but can be provided by a custom
218          * extension. This is an exception to the rule that custom extensions
219          * cannot override built in ones.
220          */
221         NULL, tls_parse_stoc_sct, NULL, tls_construct_ctos_sct,  NULL
222     },
223 #else
224     INVALID_EXTENSION,
225 #endif
226     {
227         TLSEXT_TYPE_extended_master_secret,
228         EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
229         init_ems, tls_parse_ctos_ems, tls_parse_stoc_ems,
230         tls_construct_stoc_ems, tls_construct_ctos_ems, final_ems
231     },
232     {
233         TLSEXT_TYPE_supported_versions,
234         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY | EXT_TLS1_3_ONLY,
235         NULL,
236         /* Processed inline as part of version selection */
237         NULL, NULL, NULL, tls_construct_ctos_supported_versions, NULL
238     },
239     {
240         TLSEXT_TYPE_psk_kex_modes,
241         EXT_CLIENT_HELLO | EXT_TLS_IMPLEMENTATION_ONLY | EXT_TLS1_3_ONLY,
242         init_psk_kex_modes, tls_parse_ctos_psk_kex_modes, NULL, NULL,
243         tls_construct_ctos_psk_kex_modes, NULL
244     },
245     {
246         /*
247          * Must be in this list after supported_groups. We need that to have
248          * been parsed before we do this one.
249          */
250         TLSEXT_TYPE_key_share,
251         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO
252         | EXT_TLS1_3_HELLO_RETRY_REQUEST | EXT_TLS_IMPLEMENTATION_ONLY
253         | EXT_TLS1_3_ONLY,
254         NULL, tls_parse_ctos_key_share, tls_parse_stoc_key_share,
255         tls_construct_stoc_key_share, tls_construct_ctos_key_share,
256         final_key_share
257     },
258     {
259         /*
260          * Special unsolicited ServerHello extension only used when
261          * SSL_OP_CRYPTOPRO_TLSEXT_BUG is set
262          */
263         TLSEXT_TYPE_cryptopro_bug,
264         EXT_TLS1_2_SERVER_HELLO | EXT_TLS1_2_AND_BELOW_ONLY,
265         NULL, NULL, NULL, tls_construct_stoc_cryptopro_bug, NULL, NULL
266     },
267     {
268         /* Must be immediately before pre_shared_key */
269         /* TODO(TLS1.3): Fix me */
270         TLSEXT_TYPE_padding,
271         EXT_CLIENT_HELLO,
272         NULL,
273         /* We send this, but don't read it */
274         NULL, NULL, NULL, tls_construct_ctos_padding, NULL
275     },
276     {
277         /* Required by the TLSv1.3 spec to always be the last extension */
278         TLSEXT_TYPE_psk,
279         EXT_CLIENT_HELLO | EXT_TLS1_3_SERVER_HELLO | EXT_TLS_IMPLEMENTATION_ONLY
280         | EXT_TLS1_3_ONLY,
281         NULL, tls_parse_ctos_psk, tls_parse_stoc_psk, tls_construct_stoc_psk,
282         tls_construct_ctos_psk, NULL
283     }
284 };
285
286 /*
287  * Verify whether we are allowed to use the extension |type| in the current
288  * |context|. Returns 1 to indicate the extension is allowed or unknown or 0 to
289  * indicate the extension is not allowed. If returning 1 then |*found| is set to
290  * 1 if we found a definition for the extension, and |*idx| is set to its index
291  */
292 static int verify_extension(SSL *s, unsigned int context, unsigned int type,
293                             custom_ext_methods *meths, RAW_EXTENSION *rawexlist,
294                             RAW_EXTENSION **found)
295 {
296     size_t i;
297     size_t builtin_num = OSSL_NELEM(ext_defs);
298     const EXTENSION_DEFINITION *thisext;
299
300     for (i = 0, thisext = ext_defs; i < builtin_num; i++, thisext++) {
301         if (type == thisext->type) {
302             /* Check we're allowed to use this extension in this context */
303             if ((context & thisext->context) == 0)
304                 return 0;
305
306             if (SSL_IS_DTLS(s)) {
307                 if ((thisext->context & EXT_TLS_ONLY) != 0)
308                     return 0;
309             } else if ((thisext->context & EXT_DTLS_ONLY) != 0) {
310                     return 0;
311             }
312
313             *found = &rawexlist[i];
314             return 1;
315         }
316     }
317
318     if ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) == 0) {
319         /*
320          * Custom extensions only apply to <=TLS1.2. This extension is unknown
321          * in this context - we allow it
322          */
323         *found = NULL;
324         return 1;
325     }
326
327     /* Check the custom extensions */
328     if (meths != NULL) {
329         for (i = builtin_num; i < builtin_num + meths->meths_count; i++) {
330             if (meths->meths[i - builtin_num].ext_type == type) {
331                 *found = &rawexlist[i];
332                 return 1;
333             }
334         }
335     }
336
337     /* Unknown extension. We allow it */
338     *found = NULL;
339     return 1;
340 }
341
342 /*
343  * Check whether the context defined for an extension |extctx| means whether
344  * the extension is relevant for the current context |thisctx| or not. Returns
345  * 1 if the extension is relevant for this context, and 0 otherwise
346  */
347 static int extension_is_relevant(SSL *s, unsigned int extctx,
348                                  unsigned int thisctx)
349 {
350     if ((SSL_IS_DTLS(s)
351                 && (extctx & EXT_TLS_IMPLEMENTATION_ONLY) != 0)
352             || (s->version == SSL3_VERSION
353                     && (extctx & EXT_SSL3_ALLOWED) == 0)
354             || (SSL_IS_TLS13(s)
355                 && (extctx & EXT_TLS1_2_AND_BELOW_ONLY) != 0)
356             || (!SSL_IS_TLS13(s) && (extctx & EXT_TLS1_3_ONLY) != 0))
357         return 0;
358
359     return 1;
360 }
361
362 /*
363  * Gather a list of all the extensions from the data in |packet]. |context|
364  * tells us which message this extension is for. The raw extension data is
365  * stored in |*res| on success. In the event of an error the alert type to use
366  * is stored in |*al|. We don't actually process the content of the extensions
367  * yet, except to check their types. This function also runs the initialiser
368  * functions for all known extensions (whether we have collected them or not).
369  * If successful the caller is responsible for freeing the contents of |*res|.
370  *
371  * Per http://tools.ietf.org/html/rfc5246#section-7.4.1.4, there may not be
372  * more than one extension of the same type in a ClientHello or ServerHello.
373  * This function returns 1 if all extensions are unique and we have parsed their
374  * types, and 0 if the extensions contain duplicates, could not be successfully
375  * found, or an internal error occurred. We only check duplicates for
376  * extensions that we know about. We ignore others.
377  */
378 int tls_collect_extensions(SSL *s, PACKET *packet, unsigned int context,
379                            RAW_EXTENSION **res, int *al)
380 {
381     PACKET extensions = *packet;
382     size_t i = 0;
383     custom_ext_methods *exts = NULL;
384     RAW_EXTENSION *raw_extensions = NULL;
385     const EXTENSION_DEFINITION *thisexd;
386
387     *res = NULL;
388
389     /*
390      * Initialise server side custom extensions. Client side is done during
391      * construction of extensions for the ClientHello.
392      */
393     if ((context & EXT_CLIENT_HELLO) != 0) {
394         exts = &s->cert->srv_ext;
395         custom_ext_init(&s->cert->srv_ext);
396     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
397         exts = &s->cert->cli_ext;
398     }
399
400     raw_extensions = OPENSSL_zalloc((OSSL_NELEM(ext_defs)
401                                      + (exts != NULL ? exts->meths_count : 0))
402                                      * sizeof(*raw_extensions));
403     if (raw_extensions == NULL) {
404         *al = SSL_AD_INTERNAL_ERROR;
405         SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, ERR_R_MALLOC_FAILURE);
406         return 0;
407     }
408
409     while (PACKET_remaining(&extensions) > 0) {
410         unsigned int type;
411         PACKET extension;
412         RAW_EXTENSION *thisex;
413
414         if (!PACKET_get_net_2(&extensions, &type) ||
415             !PACKET_get_length_prefixed_2(&extensions, &extension)) {
416             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
417             *al = SSL_AD_DECODE_ERROR;
418             goto err;
419         }
420         /*
421          * Verify this extension is allowed. We only check duplicates for
422          * extensions that we recognise.
423          */
424         if (!verify_extension(s, context, type, exts, raw_extensions, &thisex)
425                 || (thisex != NULL && thisex->present == 1)) {
426             SSLerr(SSL_F_TLS_COLLECT_EXTENSIONS, SSL_R_BAD_EXTENSION);
427             *al = SSL_AD_ILLEGAL_PARAMETER;
428             goto err;
429         }
430         if (thisex != NULL) {
431             thisex->data = extension;
432             thisex->present = 1;
433             thisex->type = type;
434         }
435     }
436
437     /*
438      * Initialise all known extensions relevant to this context, whether we have
439      * found them or not
440      */
441     for (thisexd = ext_defs, i = 0; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
442         if(thisexd->init != NULL && (thisexd->context & context) != 0
443                 && extension_is_relevant(s, thisexd->context, context)
444                 && !thisexd->init(s, context)) {
445             *al = SSL_AD_INTERNAL_ERROR;
446             goto err;
447         }
448     }
449
450     *res = raw_extensions;
451     return 1;
452
453  err:
454     OPENSSL_free(raw_extensions);
455     return 0;
456 }
457
458 /*
459  * Runs the parser for a given extension with index |idx|. |exts| contains the
460  * list of all parsed extensions previously collected by
461  * tls_collect_extensions(). The parser is only run if it is applicable for the
462  * given |context| and the parser has not already been run. If this is for a
463  * Certificate message, then we also provide the parser with the relevant
464  * Certificate |x| and its position in the |chainidx| with 0 being the first
465  * Certificate. Returns 1 on success or 0 on failure. In the event of a failure
466  * |*al| is populated with a suitable alert code. If an extension is not present
467  * this counted as success.
468  */
469 int tls_parse_extension(SSL *s, TLSEXT_INDEX idx, int context,
470                         RAW_EXTENSION *exts, X509 *x, size_t chainidx, int *al)
471 {
472     RAW_EXTENSION *currext = &exts[idx];
473     int (*parser)(SSL *s, PACKET *pkt, X509 *x, size_t chainidx, int *al) = NULL;
474
475     /* Skip if the extension is not present */
476     if (!currext->present)
477         return 1;
478
479     if (s->ext.debug_cb)
480         s->ext.debug_cb(s, !s->server, currext->type,
481                         PACKET_data(&currext->data),
482                         PACKET_remaining(&currext->data),
483                         s->ext.debug_arg);
484
485     /* Skip if we've already parsed this extension */
486     if (currext->parsed)
487         return 1;
488
489     currext->parsed = 1;
490
491     if (idx < OSSL_NELEM(ext_defs)) {
492         /* We are handling a built-in extension */
493         const EXTENSION_DEFINITION *extdef = &ext_defs[idx];
494
495         /* Check if extension is defined for our protocol. If not, skip */
496         if (!extension_is_relevant(s, extdef->context, context))
497             return 1;
498
499         parser = s->server ? extdef->parse_ctos : extdef->parse_stoc;
500
501         if (parser != NULL)
502             return parser(s, &currext->data, x, chainidx, al);
503
504         /*
505          * If the parser is NULL we fall through to the custom extension
506          * processing
507          */
508     }
509
510     /*
511      * This is a custom extension. We only allow this if it is a non
512      * resumed session on the server side.
513      *chain
514      * TODO(TLS1.3): We only allow old style <=TLS1.2 custom extensions.
515      * We're going to need a new mechanism for TLS1.3 to specify which
516      * messages to add the custom extensions to.
517      */
518     if ((!s->hit || !s->server)
519             && (context
520                 & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
521             && custom_ext_parse(s, s->server, currext->type,
522                                 PACKET_data(&currext->data),
523                                 PACKET_remaining(&currext->data),
524                                 al) <= 0)
525         return 0;
526
527     return 1;
528 }
529
530 /*
531  * Parse all remaining extensions that have not yet been parsed. Also calls the
532  * finalisation for all extensions at the end, whether we collected them or not.
533  * Returns 1 for success or 0 for failure. If we are working on a Certificate
534  * message then we also pass the Certificate |x| and its position in the
535  * |chainidx|, with 0 being the first certificate. On failure, |*al| is
536  * populated with a suitable alert code.
537  */
538 int tls_parse_all_extensions(SSL *s, int context, RAW_EXTENSION *exts, X509 *x,
539                              size_t chainidx, int *al)
540 {
541     size_t i, numexts = OSSL_NELEM(ext_defs);
542     const EXTENSION_DEFINITION *thisexd;
543
544     /* Calculate the number of extensions in the extensions list */
545     if ((context & EXT_CLIENT_HELLO) != 0) {
546         numexts += s->cert->srv_ext.meths_count;
547     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
548         numexts += s->cert->cli_ext.meths_count;
549     }
550
551     /* Parse each extension in turn */
552     for (i = 0; i < numexts; i++) {
553         if (!tls_parse_extension(s, i, context, exts, x, chainidx, al))
554             return 0;
555     }
556
557     /*
558      * Finalise all known extensions relevant to this context, whether we have
559      * found them or not
560      */
561     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
562         if(thisexd->final != NULL
563                 && (thisexd->context & context) != 0
564                 && !thisexd->final(s, context, exts[i].present, al))
565             return 0;
566     }
567
568     return 1;
569 }
570
571 /*
572  * Construct all the extensions relevant to the current |context| and write
573  * them to |pkt|. If this is an extension for a Certificate in a Certificate
574  * message, then |x| will be set to the Certificate we are handling, and
575  * |chainidx| will indicate the position in the chainidx we are processing (with
576  * 0 being the first in the chain). Returns 1 on success or 0 on failure. If a
577  * failure occurs then |al| is populated with a suitable alert code. On a
578  * failure construction stops at the first extension to fail to construct.
579  */
580 int tls_construct_extensions(SSL *s, WPACKET *pkt, unsigned int context,
581                              X509 *x, size_t chainidx, int *al)
582 {
583     size_t i;
584     int addcustom = 0, min_version, max_version = 0, reason, tmpal;
585     const EXTENSION_DEFINITION *thisexd;
586
587     /*
588      * Normally if something goes wrong during construction it's an internal
589      * error. We can always override this later.
590      */
591     tmpal = SSL_AD_INTERNAL_ERROR;
592
593     if (!WPACKET_start_sub_packet_u16(pkt)
594                /*
595                 * If extensions are of zero length then we don't even add the
596                 * extensions length bytes to a ClientHello/ServerHello in SSLv3
597                 */
598             || ((context & (EXT_CLIENT_HELLO | EXT_TLS1_2_SERVER_HELLO)) != 0
599                && s->version == SSL3_VERSION
600                && !WPACKET_set_flags(pkt,
601                                      WPACKET_FLAGS_ABANDON_ON_ZERO_LENGTH))) {
602         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
603         goto err;
604     }
605
606     if ((context & EXT_CLIENT_HELLO) != 0) {
607         reason = ssl_get_client_min_max_version(s, &min_version, &max_version);
608         if (reason != 0) {
609             SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, reason);
610             goto err;
611         }
612     }
613
614     /* Add custom extensions first */
615     if ((context & EXT_CLIENT_HELLO) != 0) {
616         custom_ext_init(&s->cert->cli_ext);
617         addcustom = 1;
618     } else if ((context & EXT_TLS1_2_SERVER_HELLO) != 0) {
619         /*
620          * We already initialised the custom extensions during ClientHello
621          * parsing.
622          *
623          * TODO(TLS1.3): We're going to need a new custom extension mechanism
624          * for TLS1.3, so that custom extensions can specify which of the
625          * multiple message they wish to add themselves to.
626          */
627         addcustom = 1;
628     }
629
630     if (addcustom && !custom_ext_add(s, s->server, pkt, &tmpal)) {
631         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
632         goto err;
633     }
634
635     for (i = 0, thisexd = ext_defs; i < OSSL_NELEM(ext_defs); i++, thisexd++) {
636         int (*construct)(SSL *s, WPACKET *pkt, X509 *x, size_t chainidx,
637                          int *al);
638
639         /* Skip if not relevant for our context */
640         if ((thisexd->context & context) == 0)
641             continue;
642
643         construct = s->server ? thisexd->construct_stoc
644                               : thisexd->construct_ctos;
645
646         /* Check if this extension is defined for our protocol. If not, skip */
647         if ((SSL_IS_DTLS(s)
648                     && (thisexd->context & EXT_TLS_IMPLEMENTATION_ONLY)
649                        != 0)
650                 || (s->version == SSL3_VERSION
651                         && (thisexd->context & EXT_SSL3_ALLOWED) == 0)
652                 || (SSL_IS_TLS13(s)
653                     && (thisexd->context & EXT_TLS1_2_AND_BELOW_ONLY)
654                        != 0)
655                 || (!SSL_IS_TLS13(s)
656                     && (thisexd->context & EXT_TLS1_3_ONLY) != 0
657                     && (context & EXT_CLIENT_HELLO) == 0)
658                 || ((thisexd->context & EXT_TLS1_3_ONLY) != 0
659                     && (context & EXT_CLIENT_HELLO) != 0
660                     && (SSL_IS_DTLS(s) || max_version < TLS1_3_VERSION))
661                 || construct == NULL)
662             continue;
663
664         if (!construct(s, pkt, x, chainidx, &tmpal))
665             goto err;
666     }
667
668     if (!WPACKET_close(pkt)) {
669         SSLerr(SSL_F_TLS_CONSTRUCT_EXTENSIONS, ERR_R_INTERNAL_ERROR);
670         goto err;
671     }
672
673     return 1;
674
675  err:
676     *al = tmpal;
677     return 0;
678 }
679
680 /*
681  * Built in extension finalisation and initialisation functions. All initialise
682  * or finalise the associated extension type for the given |context|. For
683  * finalisers |sent| is set to 1 if we saw the extension during parsing, and 0
684  * otherwise. These functions return 1 on success or 0 on failure. In the event
685  * of a failure then |*al| is populated with a suitable error code.
686  */
687
688 static int final_renegotiate(SSL *s, unsigned int context, int sent,
689                                      int *al)
690 {
691     if (!s->server) {
692         /*
693          * Check if we can connect to a server that doesn't support safe
694          * renegotiation
695          */
696         if (!(s->options & SSL_OP_LEGACY_SERVER_CONNECT)
697                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
698                 && !sent) {
699             *al = SSL_AD_HANDSHAKE_FAILURE;
700             SSLerr(SSL_F_FINAL_RENEGOTIATE,
701                    SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
702             return 0;
703         }
704
705         return 1;
706     }
707
708     /* Need RI if renegotiating */
709     if (s->renegotiate
710             && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION)
711             && !sent) {
712         *al = SSL_AD_HANDSHAKE_FAILURE;
713         SSLerr(SSL_F_FINAL_RENEGOTIATE,
714                SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
715         return 0;
716     }
717
718
719     return 1;
720 }
721
722 static int init_server_name(SSL *s, unsigned int context)
723 {
724     if (s->server)
725         s->servername_done = 0;
726
727     return 1;
728 }
729
730 static int final_server_name(SSL *s, unsigned int context, int sent,
731                                      int *al)
732 {
733     int ret = SSL_TLSEXT_ERR_NOACK;
734     int altmp = SSL_AD_UNRECOGNIZED_NAME;
735
736     if (s->ctx != NULL && s->ctx->ext.servername_cb != 0)
737         ret = s->ctx->ext.servername_cb(s, &altmp,
738                                         s->ctx->ext.servername_arg);
739     else if (s->initial_ctx != NULL
740              && s->initial_ctx->ext.servername_cb != 0)
741         ret = s->initial_ctx->ext.servername_cb(s, &altmp,
742                                        s->initial_ctx->ext.servername_arg);
743
744     switch (ret) {
745     case SSL_TLSEXT_ERR_ALERT_FATAL:
746         *al = altmp;
747         return 0;
748
749     case SSL_TLSEXT_ERR_ALERT_WARNING:
750         *al = altmp;
751         return 1;
752
753     case SSL_TLSEXT_ERR_NOACK:
754         s->servername_done = 0;
755         return 1;
756
757     default:
758         return 1;
759     }
760 }
761
762 #ifndef OPENSSL_NO_EC
763 static int final_ec_pt_formats(SSL *s, unsigned int context, int sent,
764                                        int *al)
765 {
766     unsigned long alg_k, alg_a;
767
768     if (s->server)
769         return 1;
770
771     alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
772     alg_a = s->s3->tmp.new_cipher->algorithm_auth;
773
774     /*
775      * If we are client and using an elliptic curve cryptography cipher
776      * suite, then if server returns an EC point formats lists extension it
777      * must contain uncompressed.
778      */
779     if (s->ext.ecpointformats != NULL
780             && s->ext.ecpointformats_len > 0
781             && s->session->ext.ecpointformats != NULL
782             && s->session->ext.ecpointformats_len > 0
783             && ((alg_k & SSL_kECDHE) || (alg_a & SSL_aECDSA))) {
784         /* we are using an ECC cipher */
785         size_t i;
786         unsigned char *list = s->session->ext.ecpointformats;
787
788         for (i = 0; i < s->session->ext.ecpointformats_len; i++) {
789             if (*list++ == TLSEXT_ECPOINTFORMAT_uncompressed)
790                 break;
791         }
792         if (i == s->session->ext.ecpointformats_len) {
793             SSLerr(SSL_F_FINAL_EC_PT_FORMATS,
794                    SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
795             return 0;
796         }
797     }
798
799     return 1;
800 }
801 #endif
802
803 static int init_session_ticket(SSL *s, unsigned int context)
804 {
805     if (!s->server)
806         s->ext.ticket_expected = 0;
807
808     return 1;
809 }
810
811 #ifndef OPENSSL_NO_OCSP
812 static int init_status_request(SSL *s, unsigned int context)
813 {
814     if (s->server) {
815         s->ext.status_type = TLSEXT_STATUSTYPE_nothing;
816     } else {
817         /*
818          * Ensure we get sensible values passed to tlsext_status_cb in the event
819          * that we don't receive a status message
820          */
821         OPENSSL_free(s->ext.ocsp.resp);
822         s->ext.ocsp.resp = NULL;
823         s->ext.ocsp.resp_len = 0;
824     }
825
826     return 1;
827 }
828 #endif
829
830 #ifndef OPENSSL_NO_NEXTPROTONEG
831 static int init_npn(SSL *s, unsigned int context)
832 {
833     s->s3->npn_seen = 0;
834
835     return 1;
836 }
837 #endif
838
839 static int init_alpn(SSL *s, unsigned int context)
840 {
841     OPENSSL_free(s->s3->alpn_selected);
842     s->s3->alpn_selected = NULL;
843     if (s->server) {
844         s->s3->alpn_selected_len = 0;
845         OPENSSL_free(s->s3->alpn_proposed);
846         s->s3->alpn_proposed = NULL;
847         s->s3->alpn_proposed_len = 0;
848     }
849     return 1;
850 }
851
852 static int final_alpn(SSL *s, unsigned int context, int sent, int *al)
853 {
854     const unsigned char *selected = NULL;
855     unsigned char selected_len = 0;
856
857     if (!s->server)
858         return 1;
859
860     if (s->ctx->ext.alpn_select_cb != NULL && s->s3->alpn_proposed != NULL) {
861         int r = s->ctx->ext.alpn_select_cb(s, &selected, &selected_len,
862                                            s->s3->alpn_proposed,
863                                            (unsigned int)s->s3->alpn_proposed_len,
864                                            s->ctx->ext.alpn_select_cb_arg);
865
866         if (r == SSL_TLSEXT_ERR_OK) {
867             OPENSSL_free(s->s3->alpn_selected);
868             s->s3->alpn_selected = OPENSSL_memdup(selected, selected_len);
869             if (s->s3->alpn_selected == NULL) {
870                 *al = SSL_AD_INTERNAL_ERROR;
871                 return 0;
872             }
873             s->s3->alpn_selected_len = selected_len;
874 #ifndef OPENSSL_NO_NEXTPROTONEG
875             /* ALPN takes precedence over NPN. */
876             s->s3->npn_seen = 0;
877 #endif
878         } else {
879             *al = SSL_AD_NO_APPLICATION_PROTOCOL;
880             return 0;
881         }
882     }
883
884     return 1;
885 }
886
887 static int init_sig_algs(SSL *s, unsigned int context)
888 {
889     /* Clear any signature algorithms extension received */
890     OPENSSL_free(s->s3->tmp.peer_sigalgs);
891     s->s3->tmp.peer_sigalgs = NULL;
892
893     return 1;
894 }
895
896 #ifndef OPENSSL_NO_SRP
897 static int init_srp(SSL *s, unsigned int context)
898 {
899     OPENSSL_free(s->srp_ctx.login);
900     s->srp_ctx.login = NULL;
901
902     return 1;
903 }
904 #endif
905
906 static int init_etm(SSL *s, unsigned int context)
907 {
908     s->s3->flags &= ~TLS1_FLAGS_ENCRYPT_THEN_MAC;
909
910     return 1;
911 }
912
913 static int init_ems(SSL *s, unsigned int context)
914 {
915     if (!s->server)
916         s->s3->flags &= ~TLS1_FLAGS_RECEIVED_EXTMS;
917
918     return 1;
919 }
920
921 static int final_ems(SSL *s, unsigned int context, int sent, int *al)
922 {
923     if (!s->server && s->hit) {
924         /*
925          * Check extended master secret extension is consistent with
926          * original session.
927          */
928         if (!(s->s3->flags & TLS1_FLAGS_RECEIVED_EXTMS) !=
929             !(s->session->flags & SSL_SESS_FLAG_EXTMS)) {
930             *al = SSL_AD_HANDSHAKE_FAILURE;
931             SSLerr(SSL_F_FINAL_EMS, SSL_R_INCONSISTENT_EXTMS);
932             return 0;
933         }
934     }
935
936     return 1;
937 }
938
939 #ifndef OPENSSL_NO_SRTP
940 static int init_srtp(SSL *s, unsigned int context)
941 {
942     if (s->server)
943         s->srtp_profile = NULL;
944
945     return 1;
946 }
947 #endif
948
949 static int final_sig_algs(SSL *s, unsigned int context, int sent, int *al)
950 {
951     if (!sent && SSL_IS_TLS13(s)) {
952         *al = TLS13_AD_MISSING_EXTENSION;
953         SSLerr(SSL_F_FINAL_SIG_ALGS, SSL_R_MISSING_SIGALGS_EXTENSION);
954         return 0;
955     }
956
957     return 1;
958 }
959
960
961 static int final_key_share(SSL *s, unsigned int context, int sent, int *al)
962 {
963     if (!SSL_IS_TLS13(s))
964         return 1;
965
966     /*
967      * If
968      *     we have no key_share
969      *     AND
970      *     (we are not resuming
971      *      OR the kex_mode doesn't allow non key_share resumes)
972      * THEN
973      *     fail
974      */
975     if (((s->server && s->s3->peer_tmp == NULL) || (!s->server && !sent))
976             && (!s->hit
977                 || (s->ext.psk_kex_mode & TLSEXT_KEX_MODE_FLAG_KE) == 0)) {
978         /* No suitable share */
979         /* TODO(TLS1.3): Send a HelloRetryRequest */
980         *al = SSL_AD_HANDSHAKE_FAILURE;
981         SSLerr(SSL_F_FINAL_KEY_SHARE, SSL_R_NO_SUITABLE_KEY_SHARE);
982         return 0;
983     }
984
985     /*
986      * For a client side resumption with no key_share we need to generate
987      * the handshake secret (otherwise this is done during key_share
988      * processing).
989      */
990     if (!sent && !s->server && !tls13_generate_handshake_secret(s, NULL, 0)) {
991         *al = SSL_AD_INTERNAL_ERROR;
992         SSLerr(SSL_F_FINAL_KEY_SHARE, ERR_R_INTERNAL_ERROR);
993         return 0;
994     }
995
996     return 1;
997 }
998
999 static int init_psk_kex_modes(SSL *s, unsigned int context)
1000 {
1001     s->ext.psk_kex_mode = TLSEXT_KEX_MODE_FLAG_NONE;
1002     return 1;
1003 }
1004
1005 int tls_psk_do_binder(SSL *s, const EVP_MD *md, const unsigned char *msgstart,
1006                       size_t binderoffset, const unsigned char *binderin,
1007                       unsigned char *binderout,
1008                       SSL_SESSION *sess, int sign)
1009 {
1010     EVP_PKEY *mackey = NULL;
1011     EVP_MD_CTX *mctx = NULL;
1012     unsigned char hash[EVP_MAX_MD_SIZE], binderkey[EVP_MAX_MD_SIZE];
1013     unsigned char finishedkey[EVP_MAX_MD_SIZE], tmpbinder[EVP_MAX_MD_SIZE];
1014     const char resumption_label[] = "resumption psk binder key";
1015     size_t bindersize, hashsize = EVP_MD_size(md);
1016     int ret = -1;
1017
1018     /* Generate the early_secret */
1019     if (!tls13_generate_secret(s, md, NULL, sess->master_key,
1020                                sess->master_key_length,
1021                                (unsigned char *)&s->early_secret)) {
1022         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1023         goto err;
1024     }
1025
1026     /*
1027      * Create the handshake hash for the binder key...the messages so far are
1028      * empty!
1029      */
1030     mctx = EVP_MD_CTX_new();
1031     if (mctx == NULL
1032             || EVP_DigestInit_ex(mctx, md, NULL) <= 0
1033             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1034         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1035         goto err;
1036     }
1037
1038     /* Generate the binder key */
1039     if (!tls13_hkdf_expand(s, md, s->early_secret,
1040                            (unsigned char *)resumption_label,
1041                            sizeof(resumption_label) - 1, hash, binderkey,
1042                            hashsize)) {
1043         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1044         goto err;
1045     }
1046
1047     /* Generate the finished key */
1048     if (!tls13_derive_finishedkey(s, md, binderkey, finishedkey, hashsize)) {
1049         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1050         goto err;
1051     }
1052
1053     /*
1054      * Get a hash of the ClientHello up to the start of the binders.
1055      * TODO(TLS1.3): This will need to be tweaked when we implement
1056      * HelloRetryRequest to include the digest of the previous messages here.
1057      */
1058     if (EVP_DigestInit_ex(mctx, md, NULL) <= 0
1059             || EVP_DigestUpdate(mctx, msgstart, binderoffset) <= 0
1060             || EVP_DigestFinal_ex(mctx, hash, NULL) <= 0) {
1061         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1062         goto err;
1063     }
1064
1065     mackey = EVP_PKEY_new_mac_key(EVP_PKEY_HMAC, NULL, finishedkey, hashsize);
1066     if (mackey == NULL) {
1067         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1068         goto err;
1069     }
1070
1071     if (!sign)
1072         binderout = tmpbinder;
1073
1074     bindersize = hashsize;
1075     if (EVP_DigestSignInit(mctx, NULL, md, NULL, mackey) <= 0
1076             || EVP_DigestSignUpdate(mctx, hash, hashsize) <= 0
1077             || EVP_DigestSignFinal(mctx, binderout, &bindersize) <= 0
1078             || bindersize != hashsize) {
1079         SSLerr(SSL_F_TLS_PSK_DO_BINDER, ERR_R_INTERNAL_ERROR);
1080         goto err;
1081     }
1082
1083     if (sign) {
1084         ret = 1;
1085     } else {
1086         /* HMAC keys can't do EVP_DigestVerify* - use CRYPTO_memcmp instead */
1087         ret = (CRYPTO_memcmp(binderin, binderout, hashsize) == 0);
1088     }
1089
1090  err:
1091     OPENSSL_cleanse(binderkey, sizeof(binderkey));
1092     OPENSSL_cleanse(finishedkey, sizeof(finishedkey));
1093     EVP_PKEY_free(mackey);
1094     EVP_MD_CTX_free(mctx);
1095
1096     return ret;
1097 }