2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5 * This package is an SSL implementation written
6 * by Eric Young (eay@cryptsoft.com).
7 * The implementation was written so as to conform with Netscapes SSL.
9 * This library is free for commercial and non-commercial use as long as
10 * the following conditions are aheared to. The following conditions
11 * apply to all code found in this distribution, be it the RC4, RSA,
12 * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13 * included with this distribution is covered by the same copyright terms
14 * except that the holder is Tim Hudson (tjh@cryptsoft.com).
16 * Copyright remains Eric Young's, and as such any Copyright notices in
17 * the code are not to be removed.
18 * If this package is used in a product, Eric Young should be given attribution
19 * as the author of the parts of the library used.
20 * This can be in the form of a textual message at program startup or
21 * in documentation (online or textual) provided with the package.
23 * Redistribution and use in source and binary forms, with or without
24 * modification, are permitted provided that the following conditions
26 * 1. Redistributions of source code must retain the copyright
27 * notice, this list of conditions and the following disclaimer.
28 * 2. Redistributions in binary form must reproduce the above copyright
29 * notice, this list of conditions and the following disclaimer in the
30 * documentation and/or other materials provided with the distribution.
31 * 3. All advertising materials mentioning features or use of this software
32 * must display the following acknowledgement:
33 * "This product includes cryptographic software written by
34 * Eric Young (eay@cryptsoft.com)"
35 * The word 'cryptographic' can be left out if the rouines from the library
36 * being used are not cryptographic related :-).
37 * 4. If you include any Windows specific code (or a derivative thereof) from
38 * the apps directory (application code) you must include an acknowledgement:
39 * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
41 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * The licence and distribution terms for any publically available version or
54 * derivative of this code cannot be changed. i.e. this code cannot simply be
55 * copied and put under another distribution licence
56 * [including the GNU Public Licence.]
58 /* ====================================================================
59 * Copyright (c) 1998-2007 The OpenSSL Project. All rights reserved.
61 * Redistribution and use in source and binary forms, with or without
62 * modification, are permitted provided that the following conditions
65 * 1. Redistributions of source code must retain the above copyright
66 * notice, this list of conditions and the following disclaimer.
68 * 2. Redistributions in binary form must reproduce the above copyright
69 * notice, this list of conditions and the following disclaimer in
70 * the documentation and/or other materials provided with the
73 * 3. All advertising materials mentioning features or use of this
74 * software must display the following acknowledgment:
75 * "This product includes software developed by the OpenSSL Project
76 * for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
78 * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
79 * endorse or promote products derived from this software without
80 * prior written permission. For written permission, please contact
81 * openssl-core@openssl.org.
83 * 5. Products derived from this software may not be called "OpenSSL"
84 * nor may "OpenSSL" appear in their names without prior written
85 * permission of the OpenSSL Project.
87 * 6. Redistributions of any form whatsoever must retain the following
89 * "This product includes software developed by the OpenSSL Project
90 * for use in the OpenSSL Toolkit (http://www.openssl.org/)"
92 * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
93 * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
94 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
95 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
96 * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
97 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
98 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
99 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
100 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
101 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
102 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
103 * OF THE POSSIBILITY OF SUCH DAMAGE.
104 * ====================================================================
106 * This product includes cryptographic software written by Eric Young
107 * (eay@cryptsoft.com). This product includes software written by Tim
108 * Hudson (tjh@cryptsoft.com).
113 #include <openssl/objects.h>
114 #include <openssl/evp.h>
115 #include <openssl/hmac.h>
116 #include "ssl_locl.h"
118 const char tls1_version_str
[]="TLSv1" OPENSSL_VERSION_PTEXT
;
120 #ifndef OPENSSL_NO_TLSEXT
121 static int tls_decrypt_ticket(SSL
*s
, const unsigned char *tick
, int ticklen
,
122 const unsigned char *sess_id
, int sesslen
,
123 SSL_SESSION
**psess
);
126 SSL3_ENC_METHOD TLSv1_enc_data
={
129 tls1_setup_key_block
,
130 tls1_generate_master_secret
,
131 tls1_change_cipher_state
,
132 tls1_final_finish_mac
,
133 TLS1_FINISH_MAC_LENGTH
,
134 tls1_cert_verify_mac
,
135 TLS_MD_CLIENT_FINISH_CONST
,TLS_MD_CLIENT_FINISH_CONST_SIZE
,
136 TLS_MD_SERVER_FINISH_CONST
,TLS_MD_SERVER_FINISH_CONST_SIZE
,
140 long tls1_default_timeout(void)
142 /* 2 hours, the 24 hours mentioned in the TLSv1 spec
143 * is way too long for http, the cache would over fill */
149 if (!ssl3_new(s
)) return(0);
150 s
->method
->ssl_clear(s
);
154 void tls1_free(SSL
*s
)
159 void tls1_clear(SSL
*s
)
162 s
->version
=TLS1_VERSION
;
165 #ifndef OPENSSL_NO_EC
166 static int nid_list
[] =
168 NID_sect163k1
, /* sect163k1 (1) */
169 NID_sect163r1
, /* sect163r1 (2) */
170 NID_sect163r2
, /* sect163r2 (3) */
171 NID_sect193r1
, /* sect193r1 (4) */
172 NID_sect193r2
, /* sect193r2 (5) */
173 NID_sect233k1
, /* sect233k1 (6) */
174 NID_sect233r1
, /* sect233r1 (7) */
175 NID_sect239k1
, /* sect239k1 (8) */
176 NID_sect283k1
, /* sect283k1 (9) */
177 NID_sect283r1
, /* sect283r1 (10) */
178 NID_sect409k1
, /* sect409k1 (11) */
179 NID_sect409r1
, /* sect409r1 (12) */
180 NID_sect571k1
, /* sect571k1 (13) */
181 NID_sect571r1
, /* sect571r1 (14) */
182 NID_secp160k1
, /* secp160k1 (15) */
183 NID_secp160r1
, /* secp160r1 (16) */
184 NID_secp160r2
, /* secp160r2 (17) */
185 NID_secp192k1
, /* secp192k1 (18) */
186 NID_X9_62_prime192v1
, /* secp192r1 (19) */
187 NID_secp224k1
, /* secp224k1 (20) */
188 NID_secp224r1
, /* secp224r1 (21) */
189 NID_secp256k1
, /* secp256k1 (22) */
190 NID_X9_62_prime256v1
, /* secp256r1 (23) */
191 NID_secp384r1
, /* secp384r1 (24) */
192 NID_secp521r1
/* secp521r1 (25) */
195 int tls1_ec_curve_id2nid(int curve_id
)
197 /* ECC curves from draft-ietf-tls-ecc-12.txt (Oct. 17, 2005) */
198 if ((curve_id
< 1) || (curve_id
> sizeof(nid_list
)/sizeof(nid_list
[0]))) return 0;
199 return nid_list
[curve_id
-1];
202 int tls1_ec_nid2curve_id(int nid
)
204 /* ECC curves from draft-ietf-tls-ecc-12.txt (Oct. 17, 2005) */
207 case NID_sect163k1
: /* sect163k1 (1) */
209 case NID_sect163r1
: /* sect163r1 (2) */
211 case NID_sect163r2
: /* sect163r2 (3) */
213 case NID_sect193r1
: /* sect193r1 (4) */
215 case NID_sect193r2
: /* sect193r2 (5) */
217 case NID_sect233k1
: /* sect233k1 (6) */
219 case NID_sect233r1
: /* sect233r1 (7) */
221 case NID_sect239k1
: /* sect239k1 (8) */
223 case NID_sect283k1
: /* sect283k1 (9) */
225 case NID_sect283r1
: /* sect283r1 (10) */
227 case NID_sect409k1
: /* sect409k1 (11) */
229 case NID_sect409r1
: /* sect409r1 (12) */
231 case NID_sect571k1
: /* sect571k1 (13) */
233 case NID_sect571r1
: /* sect571r1 (14) */
235 case NID_secp160k1
: /* secp160k1 (15) */
237 case NID_secp160r1
: /* secp160r1 (16) */
239 case NID_secp160r2
: /* secp160r2 (17) */
241 case NID_secp192k1
: /* secp192k1 (18) */
243 case NID_X9_62_prime192v1
: /* secp192r1 (19) */
245 case NID_secp224k1
: /* secp224k1 (20) */
247 case NID_secp224r1
: /* secp224r1 (21) */
249 case NID_secp256k1
: /* secp256k1 (22) */
251 case NID_X9_62_prime256v1
: /* secp256r1 (23) */
253 case NID_secp384r1
: /* secp384r1 (24) */
255 case NID_secp521r1
: /* secp521r1 (25) */
261 #endif /* OPENSSL_NO_EC */
263 #ifndef OPENSSL_NO_TLSEXT
264 unsigned char *ssl_add_clienthello_tlsext(SSL
*s
, unsigned char *p
, unsigned char *limit
)
267 unsigned char *ret
= p
;
271 if (ret
>=limit
) return NULL
; /* this really never occurs, but ... */
273 if (s
->tlsext_hostname
!= NULL
)
275 /* Add TLS extension servername to the Client Hello message */
276 unsigned long size_str
;
279 /* check for enough space.
280 4 for the servername type and entension length
281 2 for servernamelist length
282 1 for the hostname type
283 2 for hostname length
287 if ((lenmax
= limit
- ret
- 9) < 0
288 || (size_str
= strlen(s
->tlsext_hostname
)) > (unsigned long)lenmax
)
291 /* extension type and length */
292 s2n(TLSEXT_TYPE_server_name
,ret
);
295 /* length of servername list */
298 /* hostname type, length and hostname */
299 *(ret
++) = (unsigned char) TLSEXT_NAMETYPE_host_name
;
301 memcpy(ret
, s
->tlsext_hostname
, size_str
);
305 #ifndef OPENSSL_NO_EC
306 if (s
->tlsext_ecpointformatlist
!= NULL
)
308 /* Add TLS extension ECPointFormats to the ClientHello message */
311 if ((lenmax
= limit
- ret
- 5) < 0) return NULL
;
312 if (s
->tlsext_ecpointformatlist_length
> (unsigned long)lenmax
) return NULL
;
313 if (s
->tlsext_ecpointformatlist_length
> 255)
315 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT
, ERR_R_INTERNAL_ERROR
);
319 s2n(TLSEXT_TYPE_ec_point_formats
,ret
);
320 s2n(s
->tlsext_ecpointformatlist_length
+ 1,ret
);
321 *(ret
++) = (unsigned char) s
->tlsext_ecpointformatlist_length
;
322 memcpy(ret
, s
->tlsext_ecpointformatlist
, s
->tlsext_ecpointformatlist_length
);
323 ret
+=s
->tlsext_ecpointformatlist_length
;
325 if (s
->tlsext_ellipticcurvelist
!= NULL
)
327 /* Add TLS extension EllipticCurves to the ClientHello message */
330 if ((lenmax
= limit
- ret
- 6) < 0) return NULL
;
331 if (s
->tlsext_ellipticcurvelist_length
> (unsigned long)lenmax
) return NULL
;
332 if (s
->tlsext_ellipticcurvelist_length
> 65532)
334 SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT
, ERR_R_INTERNAL_ERROR
);
338 s2n(TLSEXT_TYPE_elliptic_curves
,ret
);
339 s2n(s
->tlsext_ellipticcurvelist_length
+ 2, ret
);
341 /* NB: draft-ietf-tls-ecc-12.txt uses a one-byte prefix for
342 * elliptic_curve_list, but the examples use two bytes.
343 * http://www1.ietf.org/mail-archive/web/tls/current/msg00538.html
344 * resolves this to two bytes.
346 s2n(s
->tlsext_ellipticcurvelist_length
, ret
);
347 memcpy(ret
, s
->tlsext_ellipticcurvelist
, s
->tlsext_ellipticcurvelist_length
);
348 ret
+=s
->tlsext_ellipticcurvelist_length
;
350 #endif /* OPENSSL_NO_EC */
352 if (!(SSL_get_options(s
) & SSL_OP_NO_TICKET
))
355 if (s
->session
&& s
->session
->tlsext_tick
)
356 ticklen
= s
->session
->tlsext_ticklen
;
359 /* Check for enough room 2 for extension type, 2 for len
362 if ((long)(limit
- ret
- 4 - ticklen
) < 0) return NULL
;
363 s2n(TLSEXT_TYPE_session_ticket
,ret
);
367 memcpy(ret
, s
->session
->tlsext_tick
, ticklen
);
372 #ifdef TLSEXT_TYPE_opaque_prf_input
373 if (s
->s3
->client_opaque_prf_input
!= NULL
)
375 size_t col
= s
->s3
->client_opaque_prf_input_len
;
377 if ((long)(limit
- ret
- 6 - col
< 0))
379 if (col
> 0xFFFD) /* can't happen */
382 s2n(TLSEXT_TYPE_opaque_prf_input
, ret
);
385 memcpy(ret
, s
->s3
->client_opaque_prf_input
, col
);
390 if ((extdatalen
= ret
-p
-2)== 0)
397 unsigned char *ssl_add_serverhello_tlsext(SSL
*s
, unsigned char *p
, unsigned char *limit
)
400 unsigned char *ret
= p
;
403 if (ret
>=limit
) return NULL
; /* this really never occurs, but ... */
405 if (!s
->hit
&& s
->servername_done
== 1 && s
->session
->tlsext_hostname
!= NULL
)
407 if ((long)(limit
- ret
- 4) < 0) return NULL
;
409 s2n(TLSEXT_TYPE_server_name
,ret
);
412 #ifndef OPENSSL_NO_EC
413 if (s
->tlsext_ecpointformatlist
!= NULL
)
415 /* Add TLS extension ECPointFormats to the ServerHello message */
418 if ((lenmax
= limit
- ret
- 5) < 0) return NULL
;
419 if (s
->tlsext_ecpointformatlist_length
> (unsigned long)lenmax
) return NULL
;
420 if (s
->tlsext_ecpointformatlist_length
> 255)
422 SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT
, ERR_R_INTERNAL_ERROR
);
426 s2n(TLSEXT_TYPE_ec_point_formats
,ret
);
427 s2n(s
->tlsext_ecpointformatlist_length
+ 1,ret
);
428 *(ret
++) = (unsigned char) s
->tlsext_ecpointformatlist_length
;
429 memcpy(ret
, s
->tlsext_ecpointformatlist
, s
->tlsext_ecpointformatlist_length
);
430 ret
+=s
->tlsext_ecpointformatlist_length
;
433 /* Currently the server should not respond with a SupportedCurves extension */
434 #endif /* OPENSSL_NO_EC */
436 if (s
->tlsext_ticket_expected
437 && !(SSL_get_options(s
) & SSL_OP_NO_TICKET
))
439 if ((long)(limit
- ret
- 4) < 0) return NULL
;
440 s2n(TLSEXT_TYPE_session_ticket
,ret
);
444 #ifdef TLSEXT_TYPE_opaque_prf_input
445 if (s
->s3
->server_opaque_prf_input
!= NULL
)
447 size_t sol
= s
->s3
->server_opaque_prf_input_len
;
449 if ((long)(limit
- ret
- 6 - sol
) < 0)
451 if (sol
> 0xFFFD) /* can't happen */
454 s2n(TLSEXT_TYPE_opaque_prf_input
, ret
);
457 memcpy(ret
, s
->s3
->server_opaque_prf_input
, sol
);
462 if ((extdatalen
= ret
-p
-2)== 0)
469 int ssl_parse_clienthello_tlsext(SSL
*s
, unsigned char **p
, unsigned char *d
, int n
, int *al
)
474 unsigned char *data
= *p
;
475 s
->servername_done
= 0;
481 if (data
> (d
+n
-len
))
484 while (data
<= (d
+n
-4))
489 if (data
+size
> (d
+n
))
492 if (s
->tlsext_debug_cb
)
493 s
->tlsext_debug_cb(s
, 0, type
, data
, size
,
494 s
->tlsext_debug_arg
);
495 /* The servername extension is treated as follows:
497 - Only the hostname type is supported with a maximum length of 255.
498 - The servername is rejected if too long or if it contains zeros,
499 in which case an fatal alert is generated.
500 - The servername field is maintained together with the session cache.
501 - When a session is resumed, the servername call back invoked in order
502 to allow the application to position itself to the right context.
503 - The servername is acknowledged if it is new for a session or when
504 it is identical to a previously used for the same session.
505 Applications can control the behaviour. They can at any time
506 set a 'desirable' servername for a new SSL object. This can be the
507 case for example with HTTPS when a Host: header field is received and
508 a renegotiation is requested. In this case, a possible servername
509 presented in the new client hello is only acknowledged if it matches
510 the value of the Host: field.
511 - Applications must use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
512 if they provide for changing an explicit servername context for the session,
513 i.e. when the session has been established with a servername extension.
514 - On session reconnect, the servername extension may be absent.
518 if (type
== TLSEXT_TYPE_server_name
)
520 unsigned char *sdata
;
526 *al
= SSL_AD_DECODE_ERROR
;
533 *al
= SSL_AD_DECODE_ERROR
;
540 servname_type
= *(sdata
++);
546 *al
= SSL_AD_DECODE_ERROR
;
549 if (s
->servername_done
== 0)
550 switch (servname_type
)
552 case TLSEXT_NAMETYPE_host_name
:
553 if (s
->session
->tlsext_hostname
== NULL
)
555 if (len
> TLSEXT_MAXLEN_host_name
||
556 ((s
->session
->tlsext_hostname
= OPENSSL_malloc(len
+1)) == NULL
))
558 *al
= TLS1_AD_UNRECOGNIZED_NAME
;
561 memcpy(s
->session
->tlsext_hostname
, sdata
, len
);
562 s
->session
->tlsext_hostname
[len
]='\0';
563 if (strlen(s
->session
->tlsext_hostname
) != len
) {
564 OPENSSL_free(s
->session
->tlsext_hostname
);
565 *al
= TLS1_AD_UNRECOGNIZED_NAME
;
568 s
->servername_done
= 1;
572 s
->servername_done
= strlen(s
->session
->tlsext_hostname
) == len
573 && strncmp(s
->session
->tlsext_hostname
, (char *)sdata
, len
) == 0;
585 *al
= SSL_AD_DECODE_ERROR
;
591 #ifndef OPENSSL_NO_EC
592 else if (type
== TLSEXT_TYPE_ec_point_formats
)
594 unsigned char *sdata
= data
;
595 int ecpointformatlist_length
= *(sdata
++);
597 if (ecpointformatlist_length
!= size
- 1)
599 *al
= TLS1_AD_DECODE_ERROR
;
602 s
->session
->tlsext_ecpointformatlist_length
= 0;
603 if (s
->session
->tlsext_ecpointformatlist
!= NULL
) OPENSSL_free(s
->session
->tlsext_ecpointformatlist
);
604 if ((s
->session
->tlsext_ecpointformatlist
= OPENSSL_malloc(ecpointformatlist_length
)) == NULL
)
606 *al
= TLS1_AD_INTERNAL_ERROR
;
609 s
->session
->tlsext_ecpointformatlist_length
= ecpointformatlist_length
;
610 memcpy(s
->session
->tlsext_ecpointformatlist
, sdata
, ecpointformatlist_length
);
612 fprintf(stderr
,"ssl_parse_clienthello_tlsext s->session->tlsext_ecpointformatlist (length=%i) ", s
->session
->tlsext_ecpointformatlist_length
);
613 sdata
= s
->session
->tlsext_ecpointformatlist
;
614 for (i
= 0; i
< s
->session
->tlsext_ecpointformatlist_length
; i
++)
615 fprintf(stderr
,"%i ",*(sdata
++));
616 fprintf(stderr
,"\n");
619 else if (type
== TLSEXT_TYPE_elliptic_curves
)
621 unsigned char *sdata
= data
;
622 int ellipticcurvelist_length
= (*(sdata
++) << 8);
623 ellipticcurvelist_length
+= (*(sdata
++));
625 if (ellipticcurvelist_length
!= size
- 2)
627 *al
= TLS1_AD_DECODE_ERROR
;
630 s
->session
->tlsext_ellipticcurvelist_length
= 0;
631 if (s
->session
->tlsext_ellipticcurvelist
!= NULL
) OPENSSL_free(s
->session
->tlsext_ellipticcurvelist
);
632 if ((s
->session
->tlsext_ellipticcurvelist
= OPENSSL_malloc(ellipticcurvelist_length
)) == NULL
)
634 *al
= TLS1_AD_INTERNAL_ERROR
;
637 s
->session
->tlsext_ellipticcurvelist_length
= ellipticcurvelist_length
;
638 memcpy(s
->session
->tlsext_ellipticcurvelist
, sdata
, ellipticcurvelist_length
);
640 fprintf(stderr
,"ssl_parse_clienthello_tlsext s->session->tlsext_ellipticcurvelist (length=%i) ", s
->session
->tlsext_ellipticcurvelist_length
);
641 sdata
= s
->session
->tlsext_ellipticcurvelist
;
642 for (i
= 0; i
< s
->session
->tlsext_ellipticcurvelist_length
; i
++)
643 fprintf(stderr
,"%i ",*(sdata
++));
644 fprintf(stderr
,"\n");
647 #endif /* OPENSSL_NO_EC */
648 #ifdef TLSEXT_TYPE_opaque_prf_input
649 else if (type
== TLSEXT_TYPE_opaque_prf_input
)
651 unsigned char *sdata
= data
;
655 *al
= SSL_AD_DECODE_ERROR
;
658 n2s(sdata
, s
->s3
->client_opaque_prf_input_len
);
659 if (s
->s3
->client_opaque_prf_input_len
!= size
- 2)
661 *al
= SSL_AD_DECODE_ERROR
;
665 if (s
->s3
->client_opaque_prf_input
!= NULL
) /* shouldn't really happen */
666 OPENSSL_free(s
->s3
->client_opaque_prf_input
);
668 s
->s3
->client_opaque_prf_input
= BUF_memdup(sdata
, s
->s3
->client_opaque_prf_input_len
);
669 if (s
->s3
->client_opaque_prf_input
== NULL
)
671 *al
= TLS1_AD_INTERNAL_ERROR
;
677 /* session ticket processed earlier */
685 int ssl_parse_serverhello_tlsext(SSL
*s
, unsigned char **p
, unsigned char *d
, int n
, int *al
)
690 unsigned char *data
= *p
;
692 int tlsext_servername
= 0;
699 while(data
<= (d
+n
-4))
704 if (data
+size
> (d
+n
))
707 if (s
->tlsext_debug_cb
)
708 s
->tlsext_debug_cb(s
, 1, type
, data
, size
,
709 s
->tlsext_debug_arg
);
711 if (type
== TLSEXT_TYPE_server_name
)
713 if (s
->tlsext_hostname
== NULL
|| size
> 0)
715 *al
= TLS1_AD_UNRECOGNIZED_NAME
;
718 tlsext_servername
= 1;
721 #ifndef OPENSSL_NO_EC
722 else if (type
== TLSEXT_TYPE_ec_point_formats
)
724 unsigned char *sdata
= data
;
725 int ecpointformatlist_length
= *(sdata
++);
727 if (ecpointformatlist_length
!= size
- 1)
729 *al
= TLS1_AD_DECODE_ERROR
;
732 s
->session
->tlsext_ecpointformatlist_length
= 0;
733 if (s
->session
->tlsext_ecpointformatlist
!= NULL
) OPENSSL_free(s
->session
->tlsext_ecpointformatlist
);
734 if ((s
->session
->tlsext_ecpointformatlist
= OPENSSL_malloc(ecpointformatlist_length
)) == NULL
)
736 *al
= TLS1_AD_INTERNAL_ERROR
;
739 s
->session
->tlsext_ecpointformatlist_length
= ecpointformatlist_length
;
740 memcpy(s
->session
->tlsext_ecpointformatlist
, sdata
, ecpointformatlist_length
);
742 fprintf(stderr
,"ssl_parse_serverhello_tlsext s->session->tlsext_ecpointformatlist ");
743 sdata
= s
->session
->tlsext_ecpointformatlist
;
744 for (i
= 0; i
< s
->session
->tlsext_ecpointformatlist_length
; i
++)
745 fprintf(stderr
,"%i ",*(sdata
++));
746 fprintf(stderr
,"\n");
749 #endif /* OPENSSL_NO_EC */
751 else if (type
== TLSEXT_TYPE_session_ticket
)
753 if ((SSL_get_options(s
) & SSL_OP_NO_TICKET
)
756 *al
= TLS1_AD_UNSUPPORTED_EXTENSION
;
759 s
->tlsext_ticket_expected
= 1;
761 #ifdef TLSEXT_TYPE_opaque_prf_input
762 else if (type
== TLSEXT_TYPE_opaque_prf_input
)
764 unsigned char *sdata
= data
;
768 *al
= SSL_AD_DECODE_ERROR
;
771 n2s(sdata
, s
->s3
->server_opaque_prf_input_len
);
772 if (s
->s3
->server_opaque_prf_input_len
!= size
- 2)
774 *al
= SSL_AD_DECODE_ERROR
;
778 if (s
->s3
->server_opaque_prf_input
!= NULL
) /* shouldn't really happen */
779 OPENSSL_free(s
->s3
->server_opaque_prf_input
);
780 s
->s3
->server_opaque_prf_input
= BUF_memdup(sdata
, s
->s3
->server_opaque_prf_input_len
);
782 if (s
->s3
->server_opaque_prf_input
== NULL
)
784 *al
= TLS1_AD_INTERNAL_ERROR
;
795 *al
= SSL_AD_DECODE_ERROR
;
799 if (!s
->hit
&& tlsext_servername
== 1)
801 if (s
->tlsext_hostname
)
803 if (s
->session
->tlsext_hostname
== NULL
)
805 s
->session
->tlsext_hostname
= BUF_strdup(s
->tlsext_hostname
);
806 if (!s
->session
->tlsext_hostname
)
808 *al
= SSL_AD_UNRECOGNIZED_NAME
;
814 *al
= SSL_AD_DECODE_ERROR
;
825 int ssl_prepare_clienthello_tlsext(SSL
*s
)
827 #ifndef OPENSSL_NO_EC
828 /* If we are client and using an elliptic curve cryptography cipher suite, send the point formats
829 * and elliptic curves we support.
834 unsigned long alg_k
, alg_a
;
835 STACK_OF(SSL_CIPHER
) *cipher_stack
= SSL_get_ciphers(s
);
837 for (i
= 0; i
< sk_SSL_CIPHER_num(cipher_stack
); i
++)
839 SSL_CIPHER
*c
= sk_SSL_CIPHER_value(cipher_stack
, i
);
841 alg_k
= c
->algorithm_mkey
;
842 alg_a
= c
->algorithm_auth
;
843 if ((alg_k
& (SSL_kEECDH
|SSL_kECDHr
|SSL_kECDHe
) || (alg_a
& SSL_aECDSA
)))
849 using_ecc
= using_ecc
&& (s
->version
== TLS1_VERSION
);
852 if (s
->tlsext_ecpointformatlist
!= NULL
) OPENSSL_free(s
->tlsext_ecpointformatlist
);
853 if ((s
->tlsext_ecpointformatlist
= OPENSSL_malloc(3)) == NULL
)
855 SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT
,ERR_R_MALLOC_FAILURE
);
858 s
->tlsext_ecpointformatlist_length
= 3;
859 s
->tlsext_ecpointformatlist
[0] = TLSEXT_ECPOINTFORMAT_uncompressed
;
860 s
->tlsext_ecpointformatlist
[1] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime
;
861 s
->tlsext_ecpointformatlist
[2] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
;
863 /* we support all named elliptic curves in draft-ietf-tls-ecc-12 */
864 if (s
->tlsext_ellipticcurvelist
!= NULL
) OPENSSL_free(s
->tlsext_ellipticcurvelist
);
865 s
->tlsext_ellipticcurvelist_length
= sizeof(nid_list
)/sizeof(nid_list
[0]) * 2;
866 if ((s
->tlsext_ellipticcurvelist
= OPENSSL_malloc(s
->tlsext_ellipticcurvelist_length
)) == NULL
)
868 s
->tlsext_ellipticcurvelist_length
= 0;
869 SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT
,ERR_R_MALLOC_FAILURE
);
872 for (i
= 1, j
= s
->tlsext_ellipticcurvelist
; i
<= sizeof(nid_list
)/sizeof(nid_list
[0]); i
++)
875 #endif /* OPENSSL_NO_EC */
877 #ifdef TLSEXT_TYPE_opaque_prf_input
881 if (s
->ctx
->tlsext_opaque_prf_input_callback
!= 0)
883 r
= s
->ctx
->tlsext_opaque_prf_input_callback(s
, NULL
, 0, s
->ctx
->tlsext_opaque_prf_input_callback_arg
);
888 if (s
->tlsext_opaque_prf_input
!= NULL
)
890 if (s
->s3
->client_opaque_prf_input
!= NULL
) /* shouldn't really happen */
891 OPENSSL_free(s
->s3
->client_opaque_prf_input
);
893 s
->s3
->client_opaque_prf_input
= BUF_memdup(s
->tlsext_opaque_prf_input
, s
->tlsext_opaque_prf_input_len
);
894 if (s
->s3
->client_opaque_prf_input
== NULL
)
896 SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT
,ERR_R_MALLOC_FAILURE
);
899 s
->s3
->client_opaque_prf_input_len
= s
->tlsext_opaque_prf_input_len
;
903 /* at callback's request, insist on receiving an appropriate server opaque PRF input */
904 s
->s3
->server_opaque_prf_input_len
= s
->tlsext_opaque_prf_input_len
;
911 int ssl_prepare_serverhello_tlsext(SSL
*s
)
913 #ifndef OPENSSL_NO_EC
914 /* If we are server and using an ECC cipher suite, send the point formats we support
915 * if the client sent us an ECPointsFormat extension. Note that the server is not
916 * supposed to send an EllipticCurves extension.
919 unsigned long alg_k
= s
->s3
->tmp
.new_cipher
->algorithm_mkey
;
920 unsigned long alg_a
= s
->s3
->tmp
.new_cipher
->algorithm_auth
;
921 int using_ecc
= (alg_k
& (SSL_kEECDH
|SSL_kECDHr
|SSL_kECDHe
)) || (alg_a
& SSL_aECDSA
);
922 using_ecc
= using_ecc
&& (s
->session
->tlsext_ecpointformatlist
!= NULL
);
926 if (s
->tlsext_ecpointformatlist
!= NULL
) OPENSSL_free(s
->tlsext_ecpointformatlist
);
927 if ((s
->tlsext_ecpointformatlist
= OPENSSL_malloc(3)) == NULL
)
929 SSLerr(SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT
,ERR_R_MALLOC_FAILURE
);
932 s
->tlsext_ecpointformatlist_length
= 3;
933 s
->tlsext_ecpointformatlist
[0] = TLSEXT_ECPOINTFORMAT_uncompressed
;
934 s
->tlsext_ecpointformatlist
[1] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime
;
935 s
->tlsext_ecpointformatlist
[2] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2
;
937 #endif /* OPENSSL_NO_EC */
942 int ssl_check_clienthello_tlsext(SSL
*s
)
944 int ret
=SSL_TLSEXT_ERR_NOACK
;
945 int al
= SSL_AD_UNRECOGNIZED_NAME
;
947 #ifndef OPENSSL_NO_EC
948 /* The handling of the ECPointFormats extension is done elsewhere, namely in
949 * ssl3_choose_cipher in s3_lib.c.
951 /* The handling of the EllipticCurves extension is done elsewhere, namely in
952 * ssl3_choose_cipher in s3_lib.c.
956 if (s
->ctx
!= NULL
&& s
->ctx
->tlsext_servername_callback
!= 0)
957 ret
= s
->ctx
->tlsext_servername_callback(s
, &al
, s
->ctx
->tlsext_servername_arg
);
958 else if (s
->initial_ctx
!= NULL
&& s
->initial_ctx
->tlsext_servername_callback
!= 0)
959 ret
= s
->initial_ctx
->tlsext_servername_callback(s
, &al
, s
->initial_ctx
->tlsext_servername_arg
);
962 #ifdef TLSEXT_TYPE_opaque_prf_input
964 /* This sort of belongs into ssl_prepare_serverhello_tlsext(),
965 * but we might be sending an alert in response to the client hello,
966 * so this has to happen here in ssl_check_clienthello_tlsext(). */
970 if (s
->ctx
->tlsext_opaque_prf_input_callback
!= 0)
972 r
= s
->ctx
->tlsext_opaque_prf_input_callback(s
, NULL
, 0, s
->ctx
->tlsext_opaque_prf_input_callback_arg
);
975 ret
= SSL_TLSEXT_ERR_ALERT_FATAL
;
976 al
= SSL_AD_INTERNAL_ERROR
;
981 if (s
->s3
->server_opaque_prf_input
!= NULL
) /* shouldn't really happen */
982 OPENSSL_free(s
->s3
->server_opaque_prf_input
);
983 s
->s3
->server_opaque_prf_input
= NULL
;
985 if (s
->tlsext_opaque_prf_input
!= NULL
)
987 if (s
->s3
->client_opaque_prf_input
!= NULL
&&
988 s
->s3
->client_opaque_prf_input_len
== s
->tlsext_opaque_prf_input_len
)
990 /* can only use this extension if we have a server opaque PRF input
991 * of the same length as the client opaque PRF input! */
993 s
->s3
->server_opaque_prf_input
= BUF_memdup(s
->tlsext_opaque_prf_input
, s
->tlsext_opaque_prf_input_len
);
994 if (s
->s3
->server_opaque_prf_input
== NULL
)
996 ret
= SSL_TLSEXT_ERR_ALERT_FATAL
;
997 al
= SSL_AD_INTERNAL_ERROR
;
1000 s
->s3
->server_opaque_prf_input_len
= s
->tlsext_opaque_prf_input_len
;
1004 if (r
== 2 && s
->s3
->server_opaque_prf_input
== NULL
)
1006 /* The callback wants to enforce use of the extension,
1007 * but we can't do that with the client opaque PRF input;
1008 * abort the handshake.
1010 ret
= SSL_TLSEXT_ERR_ALERT_FATAL
;
1011 al
= SSL_AD_HANDSHAKE_FAILURE
;
1019 case SSL_TLSEXT_ERR_ALERT_FATAL
:
1020 ssl3_send_alert(s
,SSL3_AL_FATAL
,al
);
1023 case SSL_TLSEXT_ERR_ALERT_WARNING
:
1024 ssl3_send_alert(s
,SSL3_AL_WARNING
,al
);
1027 case SSL_TLSEXT_ERR_NOACK
:
1028 s
->servername_done
=0;
1034 int ssl_check_serverhello_tlsext(SSL
*s
)
1036 int ret
=SSL_TLSEXT_ERR_NOACK
;
1037 int al
= SSL_AD_UNRECOGNIZED_NAME
;
1039 #ifndef OPENSSL_NO_EC
1040 /* If we are client and using an elliptic curve cryptography cipher suite, then server
1041 * must return a an EC point formats lists containing uncompressed.
1043 unsigned long alg_k
= s
->s3
->tmp
.new_cipher
->algorithm_mkey
;
1044 unsigned long alg_a
= s
->s3
->tmp
.new_cipher
->algorithm_auth
;
1045 if ((s
->tlsext_ecpointformatlist
!= NULL
) && (s
->tlsext_ecpointformatlist_length
> 0) &&
1046 ((alg_k
& (SSL_kEECDH
|SSL_kECDHr
|SSL_kECDHe
)) || (alg_a
& SSL_aECDSA
)))
1048 /* we are using an ECC cipher */
1050 unsigned char *list
;
1051 int found_uncompressed
= 0;
1052 if ((s
->session
->tlsext_ecpointformatlist
== NULL
) || (s
->session
->tlsext_ecpointformatlist_length
== 0))
1054 SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT
,SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST
);
1057 list
= s
->session
->tlsext_ecpointformatlist
;
1058 for (i
= 0; i
< s
->session
->tlsext_ecpointformatlist_length
; i
++)
1060 if (*(list
++) == TLSEXT_ECPOINTFORMAT_uncompressed
)
1062 found_uncompressed
= 1;
1066 if (!found_uncompressed
)
1068 SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT
,SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST
);
1072 ret
= SSL_TLSEXT_ERR_OK
;
1073 #endif /* OPENSSL_NO_EC */
1075 if (s
->ctx
!= NULL
&& s
->ctx
->tlsext_servername_callback
!= 0)
1076 ret
= s
->ctx
->tlsext_servername_callback(s
, &al
, s
->ctx
->tlsext_servername_arg
);
1077 else if (s
->initial_ctx
!= NULL
&& s
->initial_ctx
->tlsext_servername_callback
!= 0)
1078 ret
= s
->initial_ctx
->tlsext_servername_callback(s
, &al
, s
->initial_ctx
->tlsext_servername_arg
);
1080 #ifdef TLSEXT_TYPE_opaque_prf_input
1081 if (s
->s3
->server_opaque_prf_input_len
> 0)
1083 /* This case may indicate that we, as a client, want to insist on using opaque PRF inputs.
1084 * So first verify that we really have a value from the server too. */
1086 if (s
->s3
->server_opaque_prf_input
== NULL
)
1088 ret
= SSL_TLSEXT_ERR_ALERT_FATAL
;
1089 al
= SSL_AD_HANDSHAKE_FAILURE
;
1092 /* Anytime the server *has* sent an opaque PRF input, we need to check
1093 * that we have a client opaque PRF input of the same size. */
1094 if (s
->s3
->client_opaque_prf_input
== NULL
||
1095 s
->s3
->client_opaque_prf_input_len
!= s
->s3
->server_opaque_prf_input_len
)
1097 ret
= SSL_TLSEXT_ERR_ALERT_FATAL
;
1098 al
= SSL_AD_ILLEGAL_PARAMETER
;
1105 case SSL_TLSEXT_ERR_ALERT_FATAL
:
1106 ssl3_send_alert(s
,SSL3_AL_FATAL
,al
);
1109 case SSL_TLSEXT_ERR_ALERT_WARNING
:
1110 ssl3_send_alert(s
,SSL3_AL_WARNING
,al
);
1113 case SSL_TLSEXT_ERR_NOACK
:
1114 s
->servername_done
=0;
1120 /* Since the server cache lookup is done early on in the processing of client
1121 * hello and other operations depend on the result we need to handle any TLS
1122 * session ticket extension at the same time.
1125 int tls1_process_ticket(SSL
*s
, unsigned char *session_id
, int len
,
1126 const unsigned char *limit
, SSL_SESSION
**ret
)
1128 /* Point after session ID in client hello */
1129 const unsigned char *p
= session_id
+ len
;
1131 if ((s
->version
<= SSL3_VERSION
) || !limit
)
1135 /* Skip past cipher list */
1140 /* Skip past compression algorithm list */
1145 /* Now at start of extensions */
1146 if ((p
+ 2) >= limit
)
1149 while ((p
+ 4) <= limit
)
1151 unsigned short type
, size
;
1154 if (p
+ size
> limit
)
1156 if (type
== TLSEXT_TYPE_session_ticket
)
1158 /* If tickets disabled indicate cache miss which will
1159 * trigger a full handshake
1161 if (SSL_get_options(s
) & SSL_OP_NO_TICKET
)
1163 /* If zero length not client will accept a ticket
1164 * and indicate cache miss to trigger full handshake
1168 s
->tlsext_ticket_expected
= 1;
1169 return 0; /* Cache miss */
1171 return tls_decrypt_ticket(s
, p
, size
, session_id
, len
,
1179 static int tls_decrypt_ticket(SSL
*s
, const unsigned char *etick
, int eticklen
,
1180 const unsigned char *sess_id
, int sesslen
,
1181 SSL_SESSION
**psess
)
1184 unsigned char *sdec
;
1185 const unsigned char *p
;
1187 unsigned char tick_hmac
[EVP_MAX_MD_SIZE
];
1190 /* Attempt to process session ticket, first conduct sanity and
1191 * integrity checks on ticket.
1193 mlen
= EVP_MD_size(tlsext_tick_md());
1195 /* Need at least keyname + iv + some encrypted data */
1198 /* Check key name matches */
1199 if (memcmp(etick
, s
->ctx
->tlsext_tick_key_name
, 16))
1201 /* Check HMAC of encrypted ticket */
1202 HMAC_CTX_init(&hctx
);
1203 HMAC_Init_ex(&hctx
, s
->ctx
->tlsext_tick_hmac_key
, 16,
1204 tlsext_tick_md(), NULL
);
1205 HMAC_Update(&hctx
, etick
, eticklen
);
1206 HMAC_Final(&hctx
, tick_hmac
, NULL
);
1207 HMAC_CTX_cleanup(&hctx
);
1208 if (memcmp(tick_hmac
, etick
+ eticklen
, mlen
))
1210 /* Set p to start of IV */
1212 EVP_CIPHER_CTX_init(&ctx
);
1213 /* Attempt to decrypt session data */
1214 EVP_DecryptInit_ex(&ctx
, EVP_aes_128_cbc(), NULL
,
1215 s
->ctx
->tlsext_tick_aes_key
, p
);
1216 /* Move p after IV to start of encrypted ticket, update length */
1219 sdec
= OPENSSL_malloc(eticklen
);
1222 EVP_CIPHER_CTX_cleanup(&ctx
);
1225 EVP_DecryptUpdate(&ctx
, sdec
, &slen
, p
, eticklen
);
1226 if (EVP_DecryptFinal(&ctx
, sdec
+ slen
, &mlen
) <= 0)
1229 EVP_CIPHER_CTX_cleanup(&ctx
);
1232 sess
= d2i_SSL_SESSION(NULL
, &p
, slen
);
1236 /* The session ID if non-empty is used by some clients to
1237 * detect that the ticket has been accepted. So we copy it to
1238 * the session structure. If it is empty set length to zero
1239 * as required by standard.
1242 memcpy(sess
->session_id
, sess_id
, sesslen
);
1243 sess
->session_id_length
= sesslen
;
1247 /* If session decrypt failure indicate a cache miss and set state to
1251 s
->tlsext_ticket_expected
= 1;