Client side compression algorithm sanity checks: ensure old compression
[openssl.git] / ssl / t1_lib.c
1 /* ssl/t1_lib.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
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.
8  * 
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).
15  * 
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.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
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)"
40  * 
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
51  * SUCH DAMAGE.
52  * 
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.]
57  */
58 /* ====================================================================
59  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
60  *
61  * Redistribution and use in source and binary forms, with or without
62  * modification, are permitted provided that the following conditions
63  * are met:
64  *
65  * 1. Redistributions of source code must retain the above copyright
66  *    notice, this list of conditions and the following disclaimer. 
67  *
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
71  *    distribution.
72  *
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/)"
77  *
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.
82  *
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.
86  *
87  * 6. Redistributions of any form whatsoever must retain the following
88  *    acknowledgment:
89  *    "This product includes software developed by the OpenSSL Project
90  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
91  *
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  * ====================================================================
105  *
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).
109  *
110  */
111
112 #include <stdio.h>
113 #include <openssl/objects.h>
114 #include <openssl/evp.h>
115 #include <openssl/hmac.h>
116 #include <openssl/ocsp.h>
117 #include "ssl_locl.h"
118
119 const char tls1_version_str[]="TLSv1" OPENSSL_VERSION_PTEXT;
120
121 #ifndef OPENSSL_NO_TLSEXT
122 static int tls_decrypt_ticket(SSL *s, const unsigned char *tick, int ticklen,
123                                 const unsigned char *sess_id, int sesslen,
124                                 SSL_SESSION **psess);
125 #endif
126
127 SSL3_ENC_METHOD TLSv1_enc_data={
128         tls1_enc,
129         tls1_mac,
130         tls1_setup_key_block,
131         tls1_generate_master_secret,
132         tls1_change_cipher_state,
133         tls1_final_finish_mac,
134         TLS1_FINISH_MAC_LENGTH,
135         tls1_cert_verify_mac,
136         TLS_MD_CLIENT_FINISH_CONST,TLS_MD_CLIENT_FINISH_CONST_SIZE,
137         TLS_MD_SERVER_FINISH_CONST,TLS_MD_SERVER_FINISH_CONST_SIZE,
138         tls1_alert_code,
139         };
140
141 long tls1_default_timeout(void)
142         {
143         /* 2 hours, the 24 hours mentioned in the TLSv1 spec
144          * is way too long for http, the cache would over fill */
145         return(60*60*2);
146         }
147
148 int tls1_new(SSL *s)
149         {
150         if (!ssl3_new(s)) return(0);
151         s->method->ssl_clear(s);
152         return(1);
153         }
154
155 void tls1_free(SSL *s)
156         {
157 #ifndef OPENSSL_NO_TLSEXT
158         if (s->tlsext_session_ticket)
159                 {
160                 OPENSSL_free(s->tlsext_session_ticket);
161                 }
162 #endif /* OPENSSL_NO_TLSEXT */
163         ssl3_free(s);
164         }
165
166 void tls1_clear(SSL *s)
167         {
168         ssl3_clear(s);
169         s->version = s->method->version;
170         }
171
172 #ifndef OPENSSL_NO_EC
173 static int nid_list[] =
174         {
175                 NID_sect163k1, /* sect163k1 (1) */
176                 NID_sect163r1, /* sect163r1 (2) */
177                 NID_sect163r2, /* sect163r2 (3) */
178                 NID_sect193r1, /* sect193r1 (4) */ 
179                 NID_sect193r2, /* sect193r2 (5) */ 
180                 NID_sect233k1, /* sect233k1 (6) */
181                 NID_sect233r1, /* sect233r1 (7) */ 
182                 NID_sect239k1, /* sect239k1 (8) */ 
183                 NID_sect283k1, /* sect283k1 (9) */
184                 NID_sect283r1, /* sect283r1 (10) */ 
185                 NID_sect409k1, /* sect409k1 (11) */ 
186                 NID_sect409r1, /* sect409r1 (12) */
187                 NID_sect571k1, /* sect571k1 (13) */ 
188                 NID_sect571r1, /* sect571r1 (14) */ 
189                 NID_secp160k1, /* secp160k1 (15) */
190                 NID_secp160r1, /* secp160r1 (16) */ 
191                 NID_secp160r2, /* secp160r2 (17) */ 
192                 NID_secp192k1, /* secp192k1 (18) */
193                 NID_X9_62_prime192v1, /* secp192r1 (19) */ 
194                 NID_secp224k1, /* secp224k1 (20) */ 
195                 NID_secp224r1, /* secp224r1 (21) */
196                 NID_secp256k1, /* secp256k1 (22) */ 
197                 NID_X9_62_prime256v1, /* secp256r1 (23) */ 
198                 NID_secp384r1, /* secp384r1 (24) */
199                 NID_secp521r1  /* secp521r1 (25) */     
200         };
201         
202 int tls1_ec_curve_id2nid(int curve_id)
203         {
204         /* ECC curves from draft-ietf-tls-ecc-12.txt (Oct. 17, 2005) */
205         if ((curve_id < 1) || ((unsigned int)curve_id >
206                                 sizeof(nid_list)/sizeof(nid_list[0])))
207                 return 0;
208         return nid_list[curve_id-1];
209         }
210
211 int tls1_ec_nid2curve_id(int nid)
212         {
213         /* ECC curves from draft-ietf-tls-ecc-12.txt (Oct. 17, 2005) */
214         switch (nid)
215                 {
216         case NID_sect163k1: /* sect163k1 (1) */
217                 return 1;
218         case NID_sect163r1: /* sect163r1 (2) */
219                 return 2;
220         case NID_sect163r2: /* sect163r2 (3) */
221                 return 3;
222         case NID_sect193r1: /* sect193r1 (4) */ 
223                 return 4;
224         case NID_sect193r2: /* sect193r2 (5) */ 
225                 return 5;
226         case NID_sect233k1: /* sect233k1 (6) */
227                 return 6;
228         case NID_sect233r1: /* sect233r1 (7) */ 
229                 return 7;
230         case NID_sect239k1: /* sect239k1 (8) */ 
231                 return 8;
232         case NID_sect283k1: /* sect283k1 (9) */
233                 return 9;
234         case NID_sect283r1: /* sect283r1 (10) */ 
235                 return 10;
236         case NID_sect409k1: /* sect409k1 (11) */ 
237                 return 11;
238         case NID_sect409r1: /* sect409r1 (12) */
239                 return 12;
240         case NID_sect571k1: /* sect571k1 (13) */ 
241                 return 13;
242         case NID_sect571r1: /* sect571r1 (14) */ 
243                 return 14;
244         case NID_secp160k1: /* secp160k1 (15) */
245                 return 15;
246         case NID_secp160r1: /* secp160r1 (16) */ 
247                 return 16;
248         case NID_secp160r2: /* secp160r2 (17) */ 
249                 return 17;
250         case NID_secp192k1: /* secp192k1 (18) */
251                 return 18;
252         case NID_X9_62_prime192v1: /* secp192r1 (19) */ 
253                 return 19;
254         case NID_secp224k1: /* secp224k1 (20) */ 
255                 return 20;
256         case NID_secp224r1: /* secp224r1 (21) */
257                 return 21;
258         case NID_secp256k1: /* secp256k1 (22) */ 
259                 return 22;
260         case NID_X9_62_prime256v1: /* secp256r1 (23) */ 
261                 return 23;
262         case NID_secp384r1: /* secp384r1 (24) */
263                 return 24;
264         case NID_secp521r1:  /* secp521r1 (25) */       
265                 return 25;
266         default:
267                 return 0;
268                 }
269         }
270 #endif /* OPENSSL_NO_EC */
271
272 #ifndef OPENSSL_NO_TLSEXT
273 unsigned char *ssl_add_clienthello_tlsext(SSL *s, unsigned char *p, unsigned char *limit)
274         {
275         int extdatalen=0;
276         unsigned char *ret = p;
277
278         /* don't add extensions for SSLv3 unless doing secure renegotiation */
279         if (s->client_version == SSL3_VERSION
280                                         && !s->s3->send_connection_binding)
281                 return p;
282
283         ret+=2;
284
285         if (ret>=limit) return NULL; /* this really never occurs, but ... */
286
287         if (s->tlsext_hostname != NULL)
288                 { 
289                 /* Add TLS extension servername to the Client Hello message */
290                 unsigned long size_str;
291                 long lenmax; 
292
293                 /* check for enough space.
294                    4 for the servername type and entension length
295                    2 for servernamelist length
296                    1 for the hostname type
297                    2 for hostname length
298                    + hostname length 
299                 */
300                    
301                 if ((lenmax = limit - ret - 9) < 0 
302                     || (size_str = strlen(s->tlsext_hostname)) > (unsigned long)lenmax) 
303                         return NULL;
304                         
305                 /* extension type and length */
306                 s2n(TLSEXT_TYPE_server_name,ret); 
307                 s2n(size_str+5,ret);
308                 
309                 /* length of servername list */
310                 s2n(size_str+3,ret);
311         
312                 /* hostname type, length and hostname */
313                 *(ret++) = (unsigned char) TLSEXT_NAMETYPE_host_name;
314                 s2n(size_str,ret);
315                 memcpy(ret, s->tlsext_hostname, size_str);
316                 ret+=size_str;
317                 }
318
319         /* Add the renegotiation option: TODOEKR switch */
320         {
321           int el;
322           
323           if(!ssl_add_clienthello_renegotiate_ext(s, 0, &el, 0))
324               {
325               SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
326               return NULL;
327               }
328
329           if((limit - p - 4 - el) < 0) return NULL;
330           
331           s2n(TLSEXT_TYPE_renegotiate,ret);
332           s2n(el,ret);
333
334           if(!ssl_add_clienthello_renegotiate_ext(s, ret, &el, el))
335               {
336               SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
337               return NULL;
338               }
339
340           ret += el;
341         }
342
343 #ifndef OPENSSL_NO_EC
344         if (s->tlsext_ecpointformatlist != NULL &&
345             s->version != DTLS1_VERSION)
346                 {
347                 /* Add TLS extension ECPointFormats to the ClientHello message */
348                 long lenmax; 
349
350                 if ((lenmax = limit - ret - 5) < 0) return NULL; 
351                 if (s->tlsext_ecpointformatlist_length > (unsigned long)lenmax) return NULL;
352                 if (s->tlsext_ecpointformatlist_length > 255)
353                         {
354                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
355                         return NULL;
356                         }
357                 
358                 s2n(TLSEXT_TYPE_ec_point_formats,ret);
359                 s2n(s->tlsext_ecpointformatlist_length + 1,ret);
360                 *(ret++) = (unsigned char) s->tlsext_ecpointformatlist_length;
361                 memcpy(ret, s->tlsext_ecpointformatlist, s->tlsext_ecpointformatlist_length);
362                 ret+=s->tlsext_ecpointformatlist_length;
363                 }
364         if (s->tlsext_ellipticcurvelist != NULL &&
365             s->version != DTLS1_VERSION)
366                 {
367                 /* Add TLS extension EllipticCurves to the ClientHello message */
368                 long lenmax; 
369
370                 if ((lenmax = limit - ret - 6) < 0) return NULL; 
371                 if (s->tlsext_ellipticcurvelist_length > (unsigned long)lenmax) return NULL;
372                 if (s->tlsext_ellipticcurvelist_length > 65532)
373                         {
374                         SSLerr(SSL_F_SSL_ADD_CLIENTHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
375                         return NULL;
376                         }
377                 
378                 s2n(TLSEXT_TYPE_elliptic_curves,ret);
379                 s2n(s->tlsext_ellipticcurvelist_length + 2, ret);
380
381                 /* NB: draft-ietf-tls-ecc-12.txt uses a one-byte prefix for
382                  * elliptic_curve_list, but the examples use two bytes.
383                  * http://www1.ietf.org/mail-archive/web/tls/current/msg00538.html
384                  * resolves this to two bytes.
385                  */
386                 s2n(s->tlsext_ellipticcurvelist_length, ret);
387                 memcpy(ret, s->tlsext_ellipticcurvelist, s->tlsext_ellipticcurvelist_length);
388                 ret+=s->tlsext_ellipticcurvelist_length;
389                 }
390 #endif /* OPENSSL_NO_EC */
391
392         if (!(SSL_get_options(s) & SSL_OP_NO_TICKET))
393                 {
394                 int ticklen;
395                 if (!s->new_session && s->session && s->session->tlsext_tick)
396                         ticklen = s->session->tlsext_ticklen;
397                 else if (s->session && s->tlsext_session_ticket &&
398                          s->tlsext_session_ticket->data)
399                         {
400                         ticklen = s->tlsext_session_ticket->length;
401                         s->session->tlsext_tick = OPENSSL_malloc(ticklen);
402                         if (!s->session->tlsext_tick)
403                                 return NULL;
404                         memcpy(s->session->tlsext_tick,
405                                s->tlsext_session_ticket->data,
406                                ticklen);
407                         s->session->tlsext_ticklen = ticklen;
408                         }
409                 else
410                         ticklen = 0;
411                 if (ticklen == 0 && s->tlsext_session_ticket &&
412                     s->tlsext_session_ticket->data == NULL)
413                         goto skip_ext;
414                 /* Check for enough room 2 for extension type, 2 for len
415                  * rest for ticket
416                  */
417                 if ((long)(limit - ret - 4 - ticklen) < 0) return NULL;
418                 s2n(TLSEXT_TYPE_session_ticket,ret); 
419                 s2n(ticklen,ret);
420                 if (ticklen)
421                         {
422                         memcpy(ret, s->session->tlsext_tick, ticklen);
423                         ret += ticklen;
424                         }
425                 }
426                 skip_ext:
427
428 #ifdef TLSEXT_TYPE_opaque_prf_input
429         if (s->s3->client_opaque_prf_input != NULL &&
430             s->version != DTLS1_VERSION)
431                 {
432                 size_t col = s->s3->client_opaque_prf_input_len;
433                 
434                 if ((long)(limit - ret - 6 - col < 0))
435                         return NULL;
436                 if (col > 0xFFFD) /* can't happen */
437                         return NULL;
438
439                 s2n(TLSEXT_TYPE_opaque_prf_input, ret); 
440                 s2n(col + 2, ret);
441                 s2n(col, ret);
442                 memcpy(ret, s->s3->client_opaque_prf_input, col);
443                 ret += col;
444                 }
445 #endif
446
447         if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp &&
448             s->version != DTLS1_VERSION)
449                 {
450                 int i;
451                 long extlen, idlen, itmp;
452                 OCSP_RESPID *id;
453
454                 idlen = 0;
455                 for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++)
456                         {
457                         id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
458                         itmp = i2d_OCSP_RESPID(id, NULL);
459                         if (itmp <= 0)
460                                 return NULL;
461                         idlen += itmp + 2;
462                         }
463
464                 if (s->tlsext_ocsp_exts)
465                         {
466                         extlen = i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, NULL);
467                         if (extlen < 0)
468                                 return NULL;
469                         }
470                 else
471                         extlen = 0;
472                         
473                 if ((long)(limit - ret - 7 - extlen - idlen) < 0) return NULL;
474                 s2n(TLSEXT_TYPE_status_request, ret);
475                 if (extlen + idlen > 0xFFF0)
476                         return NULL;
477                 s2n(extlen + idlen + 5, ret);
478                 *(ret++) = TLSEXT_STATUSTYPE_ocsp;
479                 s2n(idlen, ret);
480                 for (i = 0; i < sk_OCSP_RESPID_num(s->tlsext_ocsp_ids); i++)
481                         {
482                         /* save position of id len */
483                         unsigned char *q = ret;
484                         id = sk_OCSP_RESPID_value(s->tlsext_ocsp_ids, i);
485                         /* skip over id len */
486                         ret += 2;
487                         itmp = i2d_OCSP_RESPID(id, &ret);
488                         /* write id len */
489                         s2n(itmp, q);
490                         }
491                 s2n(extlen, ret);
492                 if (extlen > 0)
493                         i2d_X509_EXTENSIONS(s->tlsext_ocsp_exts, &ret);
494                 }
495
496         if ((extdatalen = ret-p-2)== 0) 
497                 return p;
498
499         s2n(extdatalen,p);
500         return ret;
501         }
502
503 unsigned char *ssl_add_serverhello_tlsext(SSL *s, unsigned char *p, unsigned char *limit)
504         {
505         int extdatalen=0;
506         unsigned char *ret = p;
507
508         /* don't add extensions for SSLv3, unless doing secure renegotiation */
509         if (s->version == SSL3_VERSION && !s->s3->send_connection_binding)
510                 return p;
511         
512         ret+=2;
513         if (ret>=limit) return NULL; /* this really never occurs, but ... */
514
515         if (!s->hit && s->servername_done == 1 && s->session->tlsext_hostname != NULL)
516                 { 
517                 if ((long)(limit - ret - 4) < 0) return NULL; 
518
519                 s2n(TLSEXT_TYPE_server_name,ret);
520                 s2n(0,ret);
521                 }
522
523         if(s->s3->send_connection_binding)
524         {
525           int el;
526           
527           if(!ssl_add_serverhello_renegotiate_ext(s, 0, &el, 0))
528               {
529               SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
530               return NULL;
531               }
532
533           if((limit - p - 4 - el) < 0) return NULL;
534           
535           s2n(TLSEXT_TYPE_renegotiate,ret);
536           s2n(el,ret);
537
538           if(!ssl_add_serverhello_renegotiate_ext(s, ret, &el, el))
539               {
540               SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
541               return NULL;
542               }
543
544           ret += el;
545         }
546
547 #ifndef OPENSSL_NO_EC
548         if (s->tlsext_ecpointformatlist != NULL &&
549             s->version != DTLS1_VERSION)
550                 {
551                 /* Add TLS extension ECPointFormats to the ServerHello message */
552                 long lenmax; 
553
554                 if ((lenmax = limit - ret - 5) < 0) return NULL; 
555                 if (s->tlsext_ecpointformatlist_length > (unsigned long)lenmax) return NULL;
556                 if (s->tlsext_ecpointformatlist_length > 255)
557                         {
558                         SSLerr(SSL_F_SSL_ADD_SERVERHELLO_TLSEXT, ERR_R_INTERNAL_ERROR);
559                         return NULL;
560                         }
561                 
562                 s2n(TLSEXT_TYPE_ec_point_formats,ret);
563                 s2n(s->tlsext_ecpointformatlist_length + 1,ret);
564                 *(ret++) = (unsigned char) s->tlsext_ecpointformatlist_length;
565                 memcpy(ret, s->tlsext_ecpointformatlist, s->tlsext_ecpointformatlist_length);
566                 ret+=s->tlsext_ecpointformatlist_length;
567
568                 }
569         /* Currently the server should not respond with a SupportedCurves extension */
570 #endif /* OPENSSL_NO_EC */
571
572         if (s->tlsext_ticket_expected
573                 && !(SSL_get_options(s) & SSL_OP_NO_TICKET)) 
574                 { 
575                 if ((long)(limit - ret - 4) < 0) return NULL; 
576                 s2n(TLSEXT_TYPE_session_ticket,ret);
577                 s2n(0,ret);
578                 }
579
580         if (s->tlsext_status_expected)
581                 { 
582                 if ((long)(limit - ret - 4) < 0) return NULL; 
583                 s2n(TLSEXT_TYPE_status_request,ret);
584                 s2n(0,ret);
585                 }
586
587 #ifdef TLSEXT_TYPE_opaque_prf_input
588         if (s->s3->server_opaque_prf_input != NULL &&
589             s->version != DTLS1_VERSION)
590                 {
591                 size_t sol = s->s3->server_opaque_prf_input_len;
592                 
593                 if ((long)(limit - ret - 6 - sol) < 0)
594                         return NULL;
595                 if (sol > 0xFFFD) /* can't happen */
596                         return NULL;
597
598                 s2n(TLSEXT_TYPE_opaque_prf_input, ret); 
599                 s2n(sol + 2, ret);
600                 s2n(sol, ret);
601                 memcpy(ret, s->s3->server_opaque_prf_input, sol);
602                 ret += sol;
603                 }
604 #endif
605         if (((s->s3->tmp.new_cipher->id & 0xFFFF)==0x80 || (s->s3->tmp.new_cipher->id & 0xFFFF)==0x81) 
606                 && (SSL_get_options(s) & SSL_OP_CRYPTOPRO_TLSEXT_BUG))
607                 { const unsigned char cryptopro_ext[36] = {
608                         0xfd, 0xe8, /*65000*/
609                         0x00, 0x20, /*32 bytes length*/
610                         0x30, 0x1e, 0x30, 0x08, 0x06, 0x06, 0x2a, 0x85, 
611                         0x03,   0x02, 0x02, 0x09, 0x30, 0x08, 0x06, 0x06, 
612                         0x2a, 0x85, 0x03, 0x02, 0x02, 0x16, 0x30, 0x08, 
613                         0x06, 0x06, 0x2a, 0x85, 0x03, 0x02, 0x02, 0x17};
614                         if (limit-ret<36) return NULL;
615                         memcpy(ret,cryptopro_ext,36);
616                         ret+=36;
617
618                 }
619
620         if ((extdatalen = ret-p-2)== 0) 
621                 return p;
622
623         s2n(extdatalen,p);
624         return ret;
625         }
626
627 int ssl_parse_clienthello_tlsext(SSL *s, unsigned char **p, unsigned char *d, int n, int *al)
628         {
629         unsigned short type;
630         unsigned short size;
631         unsigned short len;
632         unsigned char *data = *p;
633         int renegotiate_seen = 0;
634
635         s->servername_done = 0;
636         s->tlsext_status_type = -1;
637
638         if (data >= (d+n-2))
639                 goto ri_check;
640         n2s(data,len);
641
642         if (data > (d+n-len)) 
643                 goto ri_check;
644
645         while (data <= (d+n-4))
646                 {
647                 n2s(data,type);
648                 n2s(data,size);
649
650                 if (data+size > (d+n))
651                         goto ri_check;
652 #if 0
653                 fprintf(stderr,"Received extension type %d size %d\n",type,size);
654 #endif
655                 if (s->tlsext_debug_cb)
656                         s->tlsext_debug_cb(s, 0, type, data, size,
657                                                 s->tlsext_debug_arg);
658 /* The servername extension is treated as follows:
659
660    - Only the hostname type is supported with a maximum length of 255.
661    - The servername is rejected if too long or if it contains zeros,
662      in which case an fatal alert is generated.
663    - The servername field is maintained together with the session cache.
664    - When a session is resumed, the servername call back invoked in order
665      to allow the application to position itself to the right context. 
666    - The servername is acknowledged if it is new for a session or when 
667      it is identical to a previously used for the same session. 
668      Applications can control the behaviour.  They can at any time
669      set a 'desirable' servername for a new SSL object. This can be the
670      case for example with HTTPS when a Host: header field is received and
671      a renegotiation is requested. In this case, a possible servername
672      presented in the new client hello is only acknowledged if it matches
673      the value of the Host: field. 
674    - Applications must  use SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
675      if they provide for changing an explicit servername context for the session,
676      i.e. when the session has been established with a servername extension. 
677    - On session reconnect, the servername extension may be absent. 
678
679 */      
680
681                 if (type == TLSEXT_TYPE_server_name)
682                         {
683                         unsigned char *sdata;
684                         int servname_type;
685                         int dsize; 
686                 
687                         if (size < 2) 
688                                 {
689                                 *al = SSL_AD_DECODE_ERROR;
690                                 return 0;
691                                 }
692                         n2s(data,dsize);  
693                         size -= 2;
694                         if (dsize > size  ) 
695                                 {
696                                 *al = SSL_AD_DECODE_ERROR;
697                                 return 0;
698                                 } 
699
700                         sdata = data;
701                         while (dsize > 3) 
702                                 {
703                                 servname_type = *(sdata++); 
704                                 n2s(sdata,len);
705                                 dsize -= 3;
706
707                                 if (len > dsize) 
708                                         {
709                                         *al = SSL_AD_DECODE_ERROR;
710                                         return 0;
711                                         }
712                                 if (s->servername_done == 0)
713                                 switch (servname_type)
714                                         {
715                                 case TLSEXT_NAMETYPE_host_name:
716                                         if (s->session->tlsext_hostname == NULL)
717                                                 {
718                                                 if (len > TLSEXT_MAXLEN_host_name || 
719                                                         ((s->session->tlsext_hostname = OPENSSL_malloc(len+1)) == NULL))
720                                                         {
721                                                         *al = TLS1_AD_UNRECOGNIZED_NAME;
722                                                         return 0;
723                                                         }
724                                                 memcpy(s->session->tlsext_hostname, sdata, len);
725                                                 s->session->tlsext_hostname[len]='\0';
726                                                 if (strlen(s->session->tlsext_hostname) != len) {
727                                                         OPENSSL_free(s->session->tlsext_hostname);
728                                                         s->session->tlsext_hostname = NULL;
729                                                         *al = TLS1_AD_UNRECOGNIZED_NAME;
730                                                         return 0;
731                                                 }
732                                                 s->servername_done = 1; 
733
734                                                 }
735                                         else 
736                                                 s->servername_done = strlen(s->session->tlsext_hostname) == len 
737                                                         && strncmp(s->session->tlsext_hostname, (char *)sdata, len) == 0;
738                                         
739                                         break;
740
741                                 default:
742                                         break;
743                                         }
744                                  
745                                 dsize -= len;
746                                 }
747                         if (dsize != 0) 
748                                 {
749                                 *al = SSL_AD_DECODE_ERROR;
750                                 return 0;
751                                 }
752
753                         }
754
755 #ifndef OPENSSL_NO_EC
756                 else if (type == TLSEXT_TYPE_ec_point_formats &&
757                      s->version != DTLS1_VERSION)
758                         {
759                         unsigned char *sdata = data;
760                         int ecpointformatlist_length = *(sdata++);
761
762                         if (ecpointformatlist_length != size - 1)
763                                 {
764                                 *al = TLS1_AD_DECODE_ERROR;
765                                 return 0;
766                                 }
767                         s->session->tlsext_ecpointformatlist_length = 0;
768                         if (s->session->tlsext_ecpointformatlist != NULL) OPENSSL_free(s->session->tlsext_ecpointformatlist);
769                         if ((s->session->tlsext_ecpointformatlist = OPENSSL_malloc(ecpointformatlist_length)) == NULL)
770                                 {
771                                 *al = TLS1_AD_INTERNAL_ERROR;
772                                 return 0;
773                                 }
774                         s->session->tlsext_ecpointformatlist_length = ecpointformatlist_length;
775                         memcpy(s->session->tlsext_ecpointformatlist, sdata, ecpointformatlist_length);
776 #if 0
777                         fprintf(stderr,"ssl_parse_clienthello_tlsext s->session->tlsext_ecpointformatlist (length=%i) ", s->session->tlsext_ecpointformatlist_length);
778                         sdata = s->session->tlsext_ecpointformatlist;
779                         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
780                                 fprintf(stderr,"%i ",*(sdata++));
781                         fprintf(stderr,"\n");
782 #endif
783                         }
784                 else if (type == TLSEXT_TYPE_elliptic_curves &&
785                      s->version != DTLS1_VERSION)
786                         {
787                         unsigned char *sdata = data;
788                         int ellipticcurvelist_length = (*(sdata++) << 8);
789                         ellipticcurvelist_length += (*(sdata++));
790
791                         if (ellipticcurvelist_length != size - 2)
792                                 {
793                                 *al = TLS1_AD_DECODE_ERROR;
794                                 return 0;
795                                 }
796                         s->session->tlsext_ellipticcurvelist_length = 0;
797                         if (s->session->tlsext_ellipticcurvelist != NULL) OPENSSL_free(s->session->tlsext_ellipticcurvelist);
798                         if ((s->session->tlsext_ellipticcurvelist = OPENSSL_malloc(ellipticcurvelist_length)) == NULL)
799                                 {
800                                 *al = TLS1_AD_INTERNAL_ERROR;
801                                 return 0;
802                                 }
803                         s->session->tlsext_ellipticcurvelist_length = ellipticcurvelist_length;
804                         memcpy(s->session->tlsext_ellipticcurvelist, sdata, ellipticcurvelist_length);
805 #if 0
806                         fprintf(stderr,"ssl_parse_clienthello_tlsext s->session->tlsext_ellipticcurvelist (length=%i) ", s->session->tlsext_ellipticcurvelist_length);
807                         sdata = s->session->tlsext_ellipticcurvelist;
808                         for (i = 0; i < s->session->tlsext_ellipticcurvelist_length; i++)
809                                 fprintf(stderr,"%i ",*(sdata++));
810                         fprintf(stderr,"\n");
811 #endif
812                         }
813 #endif /* OPENSSL_NO_EC */
814 #ifdef TLSEXT_TYPE_opaque_prf_input
815                 else if (type == TLSEXT_TYPE_opaque_prf_input &&
816                      s->version != DTLS1_VERSION)
817                         {
818                         unsigned char *sdata = data;
819
820                         if (size < 2)
821                                 {
822                                 *al = SSL_AD_DECODE_ERROR;
823                                 return 0;
824                                 }
825                         n2s(sdata, s->s3->client_opaque_prf_input_len);
826                         if (s->s3->client_opaque_prf_input_len != size - 2)
827                                 {
828                                 *al = SSL_AD_DECODE_ERROR;
829                                 return 0;
830                                 }
831
832                         if (s->s3->client_opaque_prf_input != NULL) /* shouldn't really happen */
833                                 OPENSSL_free(s->s3->client_opaque_prf_input);
834                         if (s->s3->client_opaque_prf_input_len == 0)
835                                 s->s3->client_opaque_prf_input = OPENSSL_malloc(1); /* dummy byte just to get non-NULL */
836                         else
837                                 s->s3->client_opaque_prf_input = BUF_memdup(sdata, s->s3->client_opaque_prf_input_len);
838                         if (s->s3->client_opaque_prf_input == NULL)
839                                 {
840                                 *al = TLS1_AD_INTERNAL_ERROR;
841                                 return 0;
842                                 }
843                         }
844 #endif
845                 else if (type == TLSEXT_TYPE_session_ticket)
846                         {
847                         if (s->tls_session_ticket_ext_cb &&
848                             !s->tls_session_ticket_ext_cb(s, data, size, s->tls_session_ticket_ext_cb_arg))
849                                 {
850                                 *al = TLS1_AD_INTERNAL_ERROR;
851                                 return 0;
852                                 }
853                         }
854                 else if (type == TLSEXT_TYPE_renegotiate)
855                         {
856                         if(!ssl_parse_clienthello_renegotiate_ext(s, data, size, al))
857                                 return 0;
858                         renegotiate_seen = 1;
859                         }
860                 else if (type == TLSEXT_TYPE_status_request &&
861                          s->version != DTLS1_VERSION && s->ctx->tlsext_status_cb)
862                         {
863                 
864                         if (size < 5) 
865                                 {
866                                 *al = SSL_AD_DECODE_ERROR;
867                                 return 0;
868                                 }
869
870                         s->tlsext_status_type = *data++;
871                         size--;
872                         if (s->tlsext_status_type == TLSEXT_STATUSTYPE_ocsp)
873                                 {
874                                 const unsigned char *sdata;
875                                 int dsize;
876                                 /* Read in responder_id_list */
877                                 n2s(data,dsize);
878                                 size -= 2;
879                                 if (dsize > size  ) 
880                                         {
881                                         *al = SSL_AD_DECODE_ERROR;
882                                         return 0;
883                                         }
884                                 while (dsize > 0)
885                                         {
886                                         OCSP_RESPID *id;
887                                         int idsize;
888                                         if (dsize < 4)
889                                                 {
890                                                 *al = SSL_AD_DECODE_ERROR;
891                                                 return 0;
892                                                 }
893                                         n2s(data, idsize);
894                                         dsize -= 2 + idsize;
895                                         if (dsize < 0)
896                                                 {
897                                                 *al = SSL_AD_DECODE_ERROR;
898                                                 return 0;
899                                                 }
900                                         sdata = data;
901                                         data += idsize;
902                                         id = d2i_OCSP_RESPID(NULL,
903                                                                 &sdata, idsize);
904                                         if (!id)
905                                                 {
906                                                 *al = SSL_AD_DECODE_ERROR;
907                                                 return 0;
908                                                 }
909                                         if (data != sdata)
910                                                 {
911                                                 OCSP_RESPID_free(id);
912                                                 *al = SSL_AD_DECODE_ERROR;
913                                                 return 0;
914                                                 }
915                                         if (!s->tlsext_ocsp_ids
916                                                 && !(s->tlsext_ocsp_ids =
917                                                 sk_OCSP_RESPID_new_null()))
918                                                 {
919                                                 OCSP_RESPID_free(id);
920                                                 *al = SSL_AD_INTERNAL_ERROR;
921                                                 return 0;
922                                                 }
923                                         if (!sk_OCSP_RESPID_push(
924                                                         s->tlsext_ocsp_ids, id))
925                                                 {
926                                                 OCSP_RESPID_free(id);
927                                                 *al = SSL_AD_INTERNAL_ERROR;
928                                                 return 0;
929                                                 }
930                                         }
931
932                                 /* Read in request_extensions */
933                                 n2s(data,dsize);
934                                 size -= 2;
935                                 if (dsize > size) 
936                                         {
937                                         *al = SSL_AD_DECODE_ERROR;
938                                         return 0;
939                                         }
940                                 sdata = data;
941                                 if (dsize > 0)
942                                         {
943                                         s->tlsext_ocsp_exts =
944                                                 d2i_X509_EXTENSIONS(NULL,
945                                                         &sdata, dsize);
946                                         if (!s->tlsext_ocsp_exts
947                                                 || (data + dsize != sdata))
948                                                 {
949                                                 *al = SSL_AD_DECODE_ERROR;
950                                                 return 0;
951                                                 }
952                                         }
953                                 }
954                                 /* We don't know what to do with any other type
955                                 * so ignore it.
956                                 */
957                                 else
958                                         s->tlsext_status_type = -1;
959                         }
960
961                 /* session ticket processed earlier */
962                 data+=size;
963                 }
964                                 
965         *p = data;
966
967         ri_check:
968
969         /* Need RI if renegotiating */
970
971         if (!renegotiate_seen && s->new_session &&
972                 !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION))
973                 {
974                 *al = SSL_AD_HANDSHAKE_FAILURE;
975                 SSLerr(SSL_F_SSL_PARSE_CLIENTHELLO_TLSEXT,
976                                 SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
977                 return 0;
978                 }
979
980         return 1;
981         }
982
983 int ssl_parse_serverhello_tlsext(SSL *s, unsigned char **p, unsigned char *d, int n, int *al)
984         {
985         unsigned short type;
986         unsigned short size;
987         unsigned short len;  
988         unsigned char *data = *p;
989         int tlsext_servername = 0;
990         int renegotiate_seen = 0;
991
992         if (data >= (d+n-2))
993                 goto ri_check;
994
995         n2s(data,len);
996
997         while(data <= (d+n-4))
998                 {
999                 n2s(data,type);
1000                 n2s(data,size);
1001
1002                 if (data+size > (d+n))
1003                         goto ri_check;
1004
1005                 if (s->tlsext_debug_cb)
1006                         s->tlsext_debug_cb(s, 1, type, data, size,
1007                                                 s->tlsext_debug_arg);
1008
1009                 if (type == TLSEXT_TYPE_server_name)
1010                         {
1011                         if (s->tlsext_hostname == NULL || size > 0)
1012                                 {
1013                                 *al = TLS1_AD_UNRECOGNIZED_NAME;
1014                                 return 0;
1015                                 }
1016                         tlsext_servername = 1;   
1017                         }
1018
1019 #ifndef OPENSSL_NO_EC
1020                 else if (type == TLSEXT_TYPE_ec_point_formats &&
1021                      s->version != DTLS1_VERSION)
1022                         {
1023                         unsigned char *sdata = data;
1024                         int ecpointformatlist_length = *(sdata++);
1025
1026                         if (ecpointformatlist_length != size - 1)
1027                                 {
1028                                 *al = TLS1_AD_DECODE_ERROR;
1029                                 return 0;
1030                                 }
1031                         s->session->tlsext_ecpointformatlist_length = 0;
1032                         if (s->session->tlsext_ecpointformatlist != NULL) OPENSSL_free(s->session->tlsext_ecpointformatlist);
1033                         if ((s->session->tlsext_ecpointformatlist = OPENSSL_malloc(ecpointformatlist_length)) == NULL)
1034                                 {
1035                                 *al = TLS1_AD_INTERNAL_ERROR;
1036                                 return 0;
1037                                 }
1038                         s->session->tlsext_ecpointformatlist_length = ecpointformatlist_length;
1039                         memcpy(s->session->tlsext_ecpointformatlist, sdata, ecpointformatlist_length);
1040 #if 0
1041                         fprintf(stderr,"ssl_parse_serverhello_tlsext s->session->tlsext_ecpointformatlist ");
1042                         sdata = s->session->tlsext_ecpointformatlist;
1043                         for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
1044                                 fprintf(stderr,"%i ",*(sdata++));
1045                         fprintf(stderr,"\n");
1046 #endif
1047                         }
1048 #endif /* OPENSSL_NO_EC */
1049
1050                 else if (type == TLSEXT_TYPE_session_ticket)
1051                         {
1052                         if (s->tls_session_ticket_ext_cb &&
1053                             !s->tls_session_ticket_ext_cb(s, data, size, s->tls_session_ticket_ext_cb_arg))
1054                                 {
1055                                 *al = TLS1_AD_INTERNAL_ERROR;
1056                                 return 0;
1057                                 }
1058                         if ((SSL_get_options(s) & SSL_OP_NO_TICKET)
1059                                 || (size > 0))
1060                                 {
1061                                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1062                                 return 0;
1063                                 }
1064                         s->tlsext_ticket_expected = 1;
1065                         }
1066 #ifdef TLSEXT_TYPE_opaque_prf_input
1067                 else if (type == TLSEXT_TYPE_opaque_prf_input &&
1068                      s->version != DTLS1_VERSION)
1069                         {
1070                         unsigned char *sdata = data;
1071
1072                         if (size < 2)
1073                                 {
1074                                 *al = SSL_AD_DECODE_ERROR;
1075                                 return 0;
1076                                 }
1077                         n2s(sdata, s->s3->server_opaque_prf_input_len);
1078                         if (s->s3->server_opaque_prf_input_len != size - 2)
1079                                 {
1080                                 *al = SSL_AD_DECODE_ERROR;
1081                                 return 0;
1082                                 }
1083                         
1084                         if (s->s3->server_opaque_prf_input != NULL) /* shouldn't really happen */
1085                                 OPENSSL_free(s->s3->server_opaque_prf_input);
1086                         if (s->s3->server_opaque_prf_input_len == 0)
1087                                 s->s3->server_opaque_prf_input = OPENSSL_malloc(1); /* dummy byte just to get non-NULL */
1088                         else
1089                                 s->s3->server_opaque_prf_input = BUF_memdup(sdata, s->s3->server_opaque_prf_input_len);
1090
1091                         if (s->s3->server_opaque_prf_input == NULL)
1092                                 {
1093                                 *al = TLS1_AD_INTERNAL_ERROR;
1094                                 return 0;
1095                                 }
1096                         }
1097 #endif
1098                 else if (type == TLSEXT_TYPE_status_request &&
1099                          s->version != DTLS1_VERSION)
1100                         {
1101                         /* MUST be empty and only sent if we've requested
1102                          * a status request message.
1103                          */ 
1104                         if ((s->tlsext_status_type == -1) || (size > 0))
1105                                 {
1106                                 *al = TLS1_AD_UNSUPPORTED_EXTENSION;
1107                                 return 0;
1108                                 }
1109                         /* Set flag to expect CertificateStatus message */
1110                         s->tlsext_status_expected = 1;
1111                         }
1112                 else if (type == TLSEXT_TYPE_renegotiate)
1113                         {
1114                         if(!ssl_parse_serverhello_renegotiate_ext(s, data, size, al))
1115                                 return 0;
1116                         renegotiate_seen = 1;
1117                         }
1118                 data+=size;             
1119                 }
1120
1121         if (data != d+n)
1122                 {
1123                 *al = SSL_AD_DECODE_ERROR;
1124                 return 0;
1125                 }
1126
1127         if (!s->hit && tlsext_servername == 1)
1128                 {
1129                 if (s->tlsext_hostname)
1130                         {
1131                         if (s->session->tlsext_hostname == NULL)
1132                                 {
1133                                 s->session->tlsext_hostname = BUF_strdup(s->tlsext_hostname);   
1134                                 if (!s->session->tlsext_hostname)
1135                                         {
1136                                         *al = SSL_AD_UNRECOGNIZED_NAME;
1137                                         return 0;
1138                                         }
1139                                 }
1140                         else 
1141                                 {
1142                                 *al = SSL_AD_DECODE_ERROR;
1143                                 return 0;
1144                                 }
1145                         }
1146                 }
1147
1148         *p = data;
1149
1150         ri_check:
1151
1152         /* Determine if we need to see RI. Strictly speaking if we want to
1153          * avoid an attack we should *always* see RI even on initial server
1154          * hello because the client doesn't see any renegotiation during an
1155          * attack. However this would mean we could not connect to any server
1156          * which doesn't support RI so for the immediate future tolerate RI
1157          * absence on initial connect only.
1158          */
1159         if (!renegotiate_seen && 
1160                 (s->new_session || !(s->options & SSL_OP_LEGACY_SERVER_CONNECT))
1161                 && !(s->options & SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION))
1162                 {
1163                 *al = SSL_AD_HANDSHAKE_FAILURE;
1164                 SSLerr(SSL_F_SSL_PARSE_SERVERHELLO_TLSEXT,
1165                                 SSL_R_UNSAFE_LEGACY_RENEGOTIATION_DISABLED);
1166                 return 0;
1167                 }
1168
1169         return 1;
1170         }
1171
1172
1173 int ssl_prepare_clienthello_tlsext(SSL *s)
1174         {
1175 #ifndef OPENSSL_NO_EC
1176         /* If we are client and using an elliptic curve cryptography cipher suite, send the point formats 
1177          * and elliptic curves we support.
1178          */
1179         int using_ecc = 0;
1180         int i;
1181         unsigned char *j;
1182         unsigned long alg_k, alg_a;
1183         STACK_OF(SSL_CIPHER) *cipher_stack = SSL_get_ciphers(s);
1184
1185         for (i = 0; i < sk_SSL_CIPHER_num(cipher_stack); i++)
1186                 {
1187                 SSL_CIPHER *c = sk_SSL_CIPHER_value(cipher_stack, i);
1188
1189                 alg_k = c->algorithm_mkey;
1190                 alg_a = c->algorithm_auth;
1191                 if ((alg_k & (SSL_kEECDH|SSL_kECDHr|SSL_kECDHe) || (alg_a & SSL_aECDSA)))
1192                         {
1193                         using_ecc = 1;
1194                         break;
1195                         }
1196                 }
1197         using_ecc = using_ecc && (s->version == TLS1_VERSION);
1198         if (using_ecc)
1199                 {
1200                 if (s->tlsext_ecpointformatlist != NULL) OPENSSL_free(s->tlsext_ecpointformatlist);
1201                 if ((s->tlsext_ecpointformatlist = OPENSSL_malloc(3)) == NULL)
1202                         {
1203                         SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,ERR_R_MALLOC_FAILURE);
1204                         return -1;
1205                         }
1206                 s->tlsext_ecpointformatlist_length = 3;
1207                 s->tlsext_ecpointformatlist[0] = TLSEXT_ECPOINTFORMAT_uncompressed;
1208                 s->tlsext_ecpointformatlist[1] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
1209                 s->tlsext_ecpointformatlist[2] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
1210
1211                 /* we support all named elliptic curves in draft-ietf-tls-ecc-12 */
1212                 if (s->tlsext_ellipticcurvelist != NULL) OPENSSL_free(s->tlsext_ellipticcurvelist);
1213                 s->tlsext_ellipticcurvelist_length = sizeof(nid_list)/sizeof(nid_list[0]) * 2;
1214                 if ((s->tlsext_ellipticcurvelist = OPENSSL_malloc(s->tlsext_ellipticcurvelist_length)) == NULL)
1215                         {
1216                         s->tlsext_ellipticcurvelist_length = 0;
1217                         SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,ERR_R_MALLOC_FAILURE);
1218                         return -1;
1219                         }
1220                 for (i = 1, j = s->tlsext_ellipticcurvelist; (unsigned int)i <=
1221                                 sizeof(nid_list)/sizeof(nid_list[0]); i++)
1222                         s2n(i,j);
1223                 }
1224 #endif /* OPENSSL_NO_EC */
1225
1226 #ifdef TLSEXT_TYPE_opaque_prf_input
1227         {
1228                 int r = 1;
1229         
1230                 if (s->ctx->tlsext_opaque_prf_input_callback != 0)
1231                         {
1232                         r = s->ctx->tlsext_opaque_prf_input_callback(s, NULL, 0, s->ctx->tlsext_opaque_prf_input_callback_arg);
1233                         if (!r)
1234                                 return -1;
1235                         }
1236
1237                 if (s->tlsext_opaque_prf_input != NULL)
1238                         {
1239                         if (s->s3->client_opaque_prf_input != NULL) /* shouldn't really happen */
1240                                 OPENSSL_free(s->s3->client_opaque_prf_input);
1241
1242                         if (s->tlsext_opaque_prf_input_len == 0)
1243                                 s->s3->client_opaque_prf_input = OPENSSL_malloc(1); /* dummy byte just to get non-NULL */
1244                         else
1245                                 s->s3->client_opaque_prf_input = BUF_memdup(s->tlsext_opaque_prf_input, s->tlsext_opaque_prf_input_len);
1246                         if (s->s3->client_opaque_prf_input == NULL)
1247                                 {
1248                                 SSLerr(SSL_F_SSL_PREPARE_CLIENTHELLO_TLSEXT,ERR_R_MALLOC_FAILURE);
1249                                 return -1;
1250                                 }
1251                         s->s3->client_opaque_prf_input_len = s->tlsext_opaque_prf_input_len;
1252                         }
1253
1254                 if (r == 2)
1255                         /* at callback's request, insist on receiving an appropriate server opaque PRF input */
1256                         s->s3->server_opaque_prf_input_len = s->tlsext_opaque_prf_input_len;
1257         }
1258 #endif
1259
1260         return 1;
1261         }
1262
1263 int ssl_prepare_serverhello_tlsext(SSL *s)
1264         {
1265 #ifndef OPENSSL_NO_EC
1266         /* If we are server and using an ECC cipher suite, send the point formats we support 
1267          * if the client sent us an ECPointsFormat extension.  Note that the server is not
1268          * supposed to send an EllipticCurves extension.
1269          */
1270
1271         unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1272         unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1273         int using_ecc = (alg_k & (SSL_kEECDH|SSL_kECDHr|SSL_kECDHe)) || (alg_a & SSL_aECDSA);
1274         using_ecc = using_ecc && (s->session->tlsext_ecpointformatlist != NULL);
1275         
1276         if (using_ecc)
1277                 {
1278                 if (s->tlsext_ecpointformatlist != NULL) OPENSSL_free(s->tlsext_ecpointformatlist);
1279                 if ((s->tlsext_ecpointformatlist = OPENSSL_malloc(3)) == NULL)
1280                         {
1281                         SSLerr(SSL_F_SSL_PREPARE_SERVERHELLO_TLSEXT,ERR_R_MALLOC_FAILURE);
1282                         return -1;
1283                         }
1284                 s->tlsext_ecpointformatlist_length = 3;
1285                 s->tlsext_ecpointformatlist[0] = TLSEXT_ECPOINTFORMAT_uncompressed;
1286                 s->tlsext_ecpointformatlist[1] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_prime;
1287                 s->tlsext_ecpointformatlist[2] = TLSEXT_ECPOINTFORMAT_ansiX962_compressed_char2;
1288                 }
1289 #endif /* OPENSSL_NO_EC */
1290
1291         return 1;
1292         }
1293
1294 int ssl_check_clienthello_tlsext(SSL *s)
1295         {
1296         int ret=SSL_TLSEXT_ERR_NOACK;
1297         int al = SSL_AD_UNRECOGNIZED_NAME;
1298
1299 #ifndef OPENSSL_NO_EC
1300         /* The handling of the ECPointFormats extension is done elsewhere, namely in 
1301          * ssl3_choose_cipher in s3_lib.c.
1302          */
1303         /* The handling of the EllipticCurves extension is done elsewhere, namely in 
1304          * ssl3_choose_cipher in s3_lib.c.
1305          */
1306 #endif
1307
1308         if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0) 
1309                 ret = s->ctx->tlsext_servername_callback(s, &al, s->ctx->tlsext_servername_arg);
1310         else if (s->initial_ctx != NULL && s->initial_ctx->tlsext_servername_callback != 0)             
1311                 ret = s->initial_ctx->tlsext_servername_callback(s, &al, s->initial_ctx->tlsext_servername_arg);
1312
1313         /* If status request then ask callback what to do.
1314          * Note: this must be called after servername callbacks in case 
1315          * the certificate has changed.
1316          */
1317         if ((s->tlsext_status_type != -1) && s->ctx && s->ctx->tlsext_status_cb)
1318                 {
1319                 int r;
1320                 r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
1321                 switch (r)
1322                         {
1323                         /* We don't want to send a status request response */
1324                         case SSL_TLSEXT_ERR_NOACK:
1325                                 s->tlsext_status_expected = 0;
1326                                 break;
1327                         /* status request response should be sent */
1328                         case SSL_TLSEXT_ERR_OK:
1329                                 if (s->tlsext_ocsp_resp)
1330                                         s->tlsext_status_expected = 1;
1331                                 else
1332                                         s->tlsext_status_expected = 0;
1333                                 break;
1334                         /* something bad happened */
1335                         case SSL_TLSEXT_ERR_ALERT_FATAL:
1336                                 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1337                                 al = SSL_AD_INTERNAL_ERROR;
1338                                 goto err;
1339                         }
1340                 }
1341         else
1342                 s->tlsext_status_expected = 0;
1343
1344 #ifdef TLSEXT_TYPE_opaque_prf_input
1345         {
1346                 /* This sort of belongs into ssl_prepare_serverhello_tlsext(),
1347                  * but we might be sending an alert in response to the client hello,
1348                  * so this has to happen here in ssl_check_clienthello_tlsext(). */
1349
1350                 int r = 1;
1351         
1352                 if (s->ctx->tlsext_opaque_prf_input_callback != 0)
1353                         {
1354                         r = s->ctx->tlsext_opaque_prf_input_callback(s, NULL, 0, s->ctx->tlsext_opaque_prf_input_callback_arg);
1355                         if (!r)
1356                                 {
1357                                 ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1358                                 al = SSL_AD_INTERNAL_ERROR;
1359                                 goto err;
1360                                 }
1361                         }
1362
1363                 if (s->s3->server_opaque_prf_input != NULL) /* shouldn't really happen */
1364                         OPENSSL_free(s->s3->server_opaque_prf_input);
1365                 s->s3->server_opaque_prf_input = NULL;
1366
1367                 if (s->tlsext_opaque_prf_input != NULL)
1368                         {
1369                         if (s->s3->client_opaque_prf_input != NULL &&
1370                                 s->s3->client_opaque_prf_input_len == s->tlsext_opaque_prf_input_len)
1371                                 {
1372                                 /* can only use this extension if we have a server opaque PRF input
1373                                  * of the same length as the client opaque PRF input! */
1374
1375                                 if (s->tlsext_opaque_prf_input_len == 0)
1376                                         s->s3->server_opaque_prf_input = OPENSSL_malloc(1); /* dummy byte just to get non-NULL */
1377                                 else
1378                                         s->s3->server_opaque_prf_input = BUF_memdup(s->tlsext_opaque_prf_input, s->tlsext_opaque_prf_input_len);
1379                                 if (s->s3->server_opaque_prf_input == NULL)
1380                                         {
1381                                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1382                                         al = SSL_AD_INTERNAL_ERROR;
1383                                         goto err;
1384                                         }
1385                                 s->s3->server_opaque_prf_input_len = s->tlsext_opaque_prf_input_len;
1386                                 }
1387                         }
1388
1389                 if (r == 2 && s->s3->server_opaque_prf_input == NULL)
1390                         {
1391                         /* The callback wants to enforce use of the extension,
1392                          * but we can't do that with the client opaque PRF input;
1393                          * abort the handshake.
1394                          */
1395                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1396                         al = SSL_AD_HANDSHAKE_FAILURE;
1397                         }
1398         }
1399
1400 #endif
1401  err:
1402         switch (ret)
1403                 {
1404                 case SSL_TLSEXT_ERR_ALERT_FATAL:
1405                         ssl3_send_alert(s,SSL3_AL_FATAL,al); 
1406                         return -1;
1407
1408                 case SSL_TLSEXT_ERR_ALERT_WARNING:
1409                         ssl3_send_alert(s,SSL3_AL_WARNING,al);
1410                         return 1; 
1411                                         
1412                 case SSL_TLSEXT_ERR_NOACK:
1413                         s->servername_done=0;
1414                         default:
1415                 return 1;
1416                 }
1417         }
1418
1419 int ssl_check_serverhello_tlsext(SSL *s)
1420         {
1421         int ret=SSL_TLSEXT_ERR_NOACK;
1422         int al = SSL_AD_UNRECOGNIZED_NAME;
1423
1424 #ifndef OPENSSL_NO_EC
1425         /* If we are client and using an elliptic curve cryptography cipher suite, then server
1426          * must return a an EC point formats lists containing uncompressed.
1427          */
1428         unsigned long alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
1429         unsigned long alg_a = s->s3->tmp.new_cipher->algorithm_auth;
1430         if ((s->tlsext_ecpointformatlist != NULL) && (s->tlsext_ecpointformatlist_length > 0) && 
1431             ((alg_k & (SSL_kEECDH|SSL_kECDHr|SSL_kECDHe)) || (alg_a & SSL_aECDSA)))
1432                 {
1433                 /* we are using an ECC cipher */
1434                 size_t i;
1435                 unsigned char *list;
1436                 int found_uncompressed = 0;
1437                 if ((s->session->tlsext_ecpointformatlist == NULL) || (s->session->tlsext_ecpointformatlist_length == 0))
1438                         {
1439                         SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1440                         return -1;
1441                         }
1442                 list = s->session->tlsext_ecpointformatlist;
1443                 for (i = 0; i < s->session->tlsext_ecpointformatlist_length; i++)
1444                         {
1445                         if (*(list++) == TLSEXT_ECPOINTFORMAT_uncompressed)
1446                                 {
1447                                 found_uncompressed = 1;
1448                                 break;
1449                                 }
1450                         }
1451                 if (!found_uncompressed)
1452                         {
1453                         SSLerr(SSL_F_SSL_CHECK_SERVERHELLO_TLSEXT,SSL_R_TLS_INVALID_ECPOINTFORMAT_LIST);
1454                         return -1;
1455                         }
1456                 }
1457         ret = SSL_TLSEXT_ERR_OK;
1458 #endif /* OPENSSL_NO_EC */
1459
1460         if (s->ctx != NULL && s->ctx->tlsext_servername_callback != 0) 
1461                 ret = s->ctx->tlsext_servername_callback(s, &al, s->ctx->tlsext_servername_arg);
1462         else if (s->initial_ctx != NULL && s->initial_ctx->tlsext_servername_callback != 0)             
1463                 ret = s->initial_ctx->tlsext_servername_callback(s, &al, s->initial_ctx->tlsext_servername_arg);
1464
1465 #ifdef TLSEXT_TYPE_opaque_prf_input
1466         if (s->s3->server_opaque_prf_input_len > 0)
1467                 {
1468                 /* This case may indicate that we, as a client, want to insist on using opaque PRF inputs.
1469                  * So first verify that we really have a value from the server too. */
1470
1471                 if (s->s3->server_opaque_prf_input == NULL)
1472                         {
1473                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1474                         al = SSL_AD_HANDSHAKE_FAILURE;
1475                         }
1476                 
1477                 /* Anytime the server *has* sent an opaque PRF input, we need to check
1478                  * that we have a client opaque PRF input of the same size. */
1479                 if (s->s3->client_opaque_prf_input == NULL ||
1480                     s->s3->client_opaque_prf_input_len != s->s3->server_opaque_prf_input_len)
1481                         {
1482                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1483                         al = SSL_AD_ILLEGAL_PARAMETER;
1484                         }
1485                 }
1486 #endif
1487
1488         /* If we've requested certificate status and we wont get one
1489          * tell the callback
1490          */
1491         if ((s->tlsext_status_type != -1) && !(s->tlsext_status_expected)
1492                         && s->ctx && s->ctx->tlsext_status_cb)
1493                 {
1494                 int r;
1495                 /* Set resp to NULL, resplen to -1 so callback knows
1496                  * there is no response.
1497                  */
1498                 if (s->tlsext_ocsp_resp)
1499                         {
1500                         OPENSSL_free(s->tlsext_ocsp_resp);
1501                         s->tlsext_ocsp_resp = NULL;
1502                         }
1503                 s->tlsext_ocsp_resplen = -1;
1504                 r = s->ctx->tlsext_status_cb(s, s->ctx->tlsext_status_arg);
1505                 if (r == 0)
1506                         {
1507                         al = SSL_AD_BAD_CERTIFICATE_STATUS_RESPONSE;
1508                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1509                         }
1510                 if (r < 0)
1511                         {
1512                         al = SSL_AD_INTERNAL_ERROR;
1513                         ret = SSL_TLSEXT_ERR_ALERT_FATAL;
1514                         }
1515                 }
1516
1517         switch (ret)
1518                 {
1519                 case SSL_TLSEXT_ERR_ALERT_FATAL:
1520                         ssl3_send_alert(s,SSL3_AL_FATAL,al); 
1521                         return -1;
1522
1523                 case SSL_TLSEXT_ERR_ALERT_WARNING:
1524                         ssl3_send_alert(s,SSL3_AL_WARNING,al);
1525                         return 1; 
1526                                         
1527                 case SSL_TLSEXT_ERR_NOACK:
1528                         s->servername_done=0;
1529                         default:
1530                 return 1;
1531                 }
1532         }
1533
1534 /* Since the server cache lookup is done early on in the processing of client
1535  * hello and other operations depend on the result we need to handle any TLS
1536  * session ticket extension at the same time.
1537  */
1538
1539 int tls1_process_ticket(SSL *s, unsigned char *session_id, int len,
1540                                 const unsigned char *limit, SSL_SESSION **ret)
1541         {
1542         /* Point after session ID in client hello */
1543         const unsigned char *p = session_id + len;
1544         unsigned short i;
1545
1546         /* If tickets disabled behave as if no ticket present
1547          * to permit stateful resumption.
1548          */
1549         if (SSL_get_options(s) & SSL_OP_NO_TICKET)
1550                 return 1;
1551
1552         if ((s->version <= SSL3_VERSION) || !limit)
1553                 return 1;
1554         if (p >= limit)
1555                 return -1;
1556         /* Skip past DTLS cookie */
1557         if (s->version == DTLS1_VERSION || s->version == DTLS1_BAD_VER)
1558                 {
1559                 i = *(p++);
1560                 p+= i;
1561                 if (p >= limit)
1562                         return -1;
1563                 }
1564         /* Skip past cipher list */
1565         n2s(p, i);
1566         p+= i;
1567         if (p >= limit)
1568                 return -1;
1569         /* Skip past compression algorithm list */
1570         i = *(p++);
1571         p += i;
1572         if (p > limit)
1573                 return -1;
1574         /* Now at start of extensions */
1575         if ((p + 2) >= limit)
1576                 return 1;
1577         n2s(p, i);
1578         while ((p + 4) <= limit)
1579                 {
1580                 unsigned short type, size;
1581                 n2s(p, type);
1582                 n2s(p, size);
1583                 if (p + size > limit)
1584                         return 1;
1585                 if (type == TLSEXT_TYPE_session_ticket)
1586                         {
1587                         /* If tickets disabled indicate cache miss which will
1588                          * trigger a full handshake
1589                          */
1590                         if (SSL_get_options(s) & SSL_OP_NO_TICKET)
1591                                 return 1;
1592                         /* If zero length note client will accept a ticket
1593                          * and indicate cache miss to trigger full handshake
1594                          */
1595                         if (size == 0)
1596                                 {
1597                                 s->tlsext_ticket_expected = 1;
1598                                 return 0;       /* Cache miss */
1599                                 }
1600                         if (s->tls_session_secret_cb)
1601                                 {
1602                                 /* Indicate cache miss here and instead of
1603                                  * generating the session from ticket now,
1604                                  * trigger abbreviated handshake based on
1605                                  * external mechanism to calculate the master
1606                                  * secret later. */
1607                                 return 0;
1608                                 }
1609                         return tls_decrypt_ticket(s, p, size, session_id, len,
1610                                                                         ret);
1611                         }
1612                 p += size;
1613                 }
1614         return 1;
1615         }
1616
1617 static int tls_decrypt_ticket(SSL *s, const unsigned char *etick, int eticklen,
1618                                 const unsigned char *sess_id, int sesslen,
1619                                 SSL_SESSION **psess)
1620         {
1621         SSL_SESSION *sess;
1622         unsigned char *sdec;
1623         const unsigned char *p;
1624         int slen, mlen, renew_ticket = 0;
1625         unsigned char tick_hmac[EVP_MAX_MD_SIZE];
1626         HMAC_CTX hctx;
1627         EVP_CIPHER_CTX ctx;
1628         SSL_CTX *tctx = s->initial_ctx;
1629         /* Need at least keyname + iv + some encrypted data */
1630         if (eticklen < 48)
1631                 goto tickerr;
1632         /* Initialize session ticket encryption and HMAC contexts */
1633         HMAC_CTX_init(&hctx);
1634         EVP_CIPHER_CTX_init(&ctx);
1635         if (tctx->tlsext_ticket_key_cb)
1636                 {
1637                 unsigned char *nctick = (unsigned char *)etick;
1638                 int rv = tctx->tlsext_ticket_key_cb(s, nctick, nctick + 16,
1639                                                         &ctx, &hctx, 0);
1640                 if (rv < 0)
1641                         return -1;
1642                 if (rv == 0)
1643                         goto tickerr;
1644                 if (rv == 2)
1645                         renew_ticket = 1;
1646                 }
1647         else
1648                 {
1649                 /* Check key name matches */
1650                 if (memcmp(etick, tctx->tlsext_tick_key_name, 16))
1651                         goto tickerr;
1652                 HMAC_Init_ex(&hctx, tctx->tlsext_tick_hmac_key, 16,
1653                                         tlsext_tick_md(), NULL);
1654                 EVP_DecryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL,
1655                                 tctx->tlsext_tick_aes_key, etick + 16);
1656                 }
1657         /* Attempt to process session ticket, first conduct sanity and
1658          * integrity checks on ticket.
1659          */
1660         mlen = HMAC_size(&hctx);
1661         if (mlen < 0)
1662                 {
1663                 EVP_CIPHER_CTX_cleanup(&ctx);
1664                 return -1;
1665                 }
1666         eticklen -= mlen;
1667         /* Check HMAC of encrypted ticket */
1668         HMAC_Update(&hctx, etick, eticklen);
1669         HMAC_Final(&hctx, tick_hmac, NULL);
1670         HMAC_CTX_cleanup(&hctx);
1671         if (memcmp(tick_hmac, etick + eticklen, mlen))
1672                 goto tickerr;
1673         /* Attempt to decrypt session data */
1674         /* Move p after IV to start of encrypted ticket, update length */
1675         p = etick + 16 + EVP_CIPHER_CTX_iv_length(&ctx);
1676         eticklen -= 16 + EVP_CIPHER_CTX_iv_length(&ctx);
1677         sdec = OPENSSL_malloc(eticklen);
1678         if (!sdec)
1679                 {
1680                 EVP_CIPHER_CTX_cleanup(&ctx);
1681                 return -1;
1682                 }
1683         EVP_DecryptUpdate(&ctx, sdec, &slen, p, eticklen);
1684         if (EVP_DecryptFinal(&ctx, sdec + slen, &mlen) <= 0)
1685                 goto tickerr;
1686         slen += mlen;
1687         EVP_CIPHER_CTX_cleanup(&ctx);
1688         p = sdec;
1689                 
1690         sess = d2i_SSL_SESSION(NULL, &p, slen);
1691         OPENSSL_free(sdec);
1692         if (sess)
1693                 {
1694                 /* The session ID if non-empty is used by some clients to
1695                  * detect that the ticket has been accepted. So we copy it to
1696                  * the session structure. If it is empty set length to zero
1697                  * as required by standard.
1698                  */
1699                 if (sesslen)
1700                         memcpy(sess->session_id, sess_id, sesslen);
1701                 sess->session_id_length = sesslen;
1702                 *psess = sess;
1703                 s->tlsext_ticket_expected = renew_ticket;
1704                 return 1;
1705                 }
1706         /* If session decrypt failure indicate a cache miss and set state to
1707          * send a new ticket
1708          */
1709         tickerr:        
1710         s->tlsext_ticket_expected = 1;
1711         return 0;
1712         }
1713
1714 #endif