7724ff5672c7d646c39bda46202fa5724eb414c9
[openssl.git] / ssl / ssl_comp.c
1 /* ssl/ssl_comp.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 #include <stdio.h>
60 #include "ssl_locl.h"
61
62 #ifndef NOPROTO
63 static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s);
64 static void SSL_SESSION_list_add(SSL_CTX *ctx,SSL_SESSION *s);
65 #else
66 static void SSL_SESSION_list_remove();
67 static void SSL_SESSION_list_add();
68 #endif
69
70 static int ssl_session_num=0;
71 static STACK *ssl_session_meth=NULL;
72
73 SSL_SESSION *SSL_get_session(ssl)
74 SSL *ssl;
75         {
76         return(ssl->session);
77         }
78
79 int SSL_SESSION_get_ex_new_index(argl,argp,new_func,dup_func,free_func)
80 long argl;
81 char *argp;
82 int (*new_func)();
83 int (*dup_func)();
84 void (*free_func)();
85         {
86         ssl_session_num++;
87         return(CRYPTO_get_ex_new_index(ssl_session_num-1,
88                 &ssl_session_meth,
89                 argl,argp,new_func,dup_func,free_func));
90         }
91
92 int SSL_SESSION_set_ex_data(s,idx,arg)
93 SSL_SESSION *s;
94 int idx;
95 char *arg;
96         {
97         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
98         }
99
100 char *SSL_SESSION_get_ex_data(s,idx)
101 SSL_SESSION *s;
102 int idx;
103         {
104         return(CRYPTO_get_ex_data(&s->ex_data,idx));
105         }
106
107 SSL_SESSION *SSL_SESSION_new()
108         {
109         SSL_SESSION *ss;
110
111         ss=(SSL_SESSION *)Malloc(sizeof(SSL_SESSION));
112         if (ss == NULL)
113                 {
114                 SSLerr(SSL_F_SSL_SESSION_NEW,ERR_R_MALLOC_FAILURE);
115                 return(0);
116                 }
117         memset(ss,0,sizeof(SSL_SESSION));
118
119         ss->references=1;
120         ss->timeout=60*5+4; /* 5 minute timeout by default */
121         ss->time=time(NULL);
122         ss->prev=NULL;
123         ss->next=NULL;
124         CRYPTO_new_ex_data(ssl_session_meth,(char *)ss,&ss->ex_data);
125         return(ss);
126         }
127
128 int ssl_get_new_session(s, session)
129 SSL *s;
130 int session;
131         {
132         SSL_SESSION *ss=NULL;
133
134         if ((ss=SSL_SESSION_new()) == NULL) return(0);
135
136         /* If the context has a default timeout, use it */
137         if (s->ctx->session_timeout != 0)
138                 ss->timeout=SSL_get_default_timeout(s);
139
140         if (s->session != NULL)
141                 {
142                 SSL_SESSION_free(s->session);
143                 s->session=NULL;
144                 }
145
146         if (session)
147                 {
148                 if (s->version == SSL2_CLIENT_VERSION)
149                         {
150                         ss->ssl_version=SSL2_VERSION;
151                         ss->session_id_length=SSL2_SSL_SESSION_ID_LENGTH;
152                         }
153                 else if (s->version == SSL3_VERSION)
154                         {
155                         ss->ssl_version=SSL3_VERSION;
156                         ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
157                         }
158                 else if (s->version == TLS1_VERSION)
159                         {
160                         ss->ssl_version=TLS1_VERSION;
161                         ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
162                         }
163                 else
164                         {
165                         SSLerr(SSL_F_SSL_GET_NEW_SESSION,SSL_R_UNSUPPORTED_SSL_VERSION);
166                         SSL_SESSION_free(ss);
167                         return(0);
168                         }
169
170                 for (;;)
171                         {
172                         SSL_SESSION *r;
173
174                         RAND_bytes(ss->session_id,ss->session_id_length);
175                         CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
176                         r=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,
177                                 (char *)ss);
178                         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
179                         if (r == NULL) break;
180                         /* else - woops a session_id match */
181                         }
182                 }
183         else
184                 {
185                 ss->session_id_length=0;
186                 }
187
188         s->session=ss;
189         ss->ssl_version=s->version;
190
191         return(1);
192         }
193
194 int ssl_get_prev_session(s,session_id,len)
195 SSL *s;
196 unsigned char *session_id;
197 int len;
198         {
199         SSL_SESSION *ret=NULL,data;
200
201         /* conn_init();*/
202         data.ssl_version=s->version;
203         data.session_id_length=len;
204         if (len > SSL_MAX_SSL_SESSION_ID_LENGTH)
205                 return(0);
206         memcpy(data.session_id,session_id,len);;
207
208         if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
209                 {
210                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
211                 ret=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,(char *)&data);
212                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
213                 }
214
215         if (ret == NULL)
216                 {
217                 int copy=1;
218
219                 s->ctx->sess_miss++;
220                 ret=NULL;
221                 if ((s->ctx->get_session_cb != NULL) &&
222                         ((ret=s->ctx->get_session_cb(s,session_id,len,&copy))
223                                 != NULL))
224                         {
225                         s->ctx->sess_cb_hit++;
226
227                         /* The following should not return 1, otherwise,
228                          * things are very strange */
229                         SSL_CTX_add_session(s->ctx,ret);
230                         /* auto free it */
231                         if (!copy)
232                                 SSL_SESSION_free(ret);
233                         }
234                 if (ret == NULL) return(0);
235                 }
236
237         if (ret->cipher == NULL)
238                 {
239                 char buf[5],*p;
240                 unsigned long l;
241
242                 p=buf;
243                 l=ret->cipher_id;
244                 l2n(l,p);
245                 if ((ret->ssl_version>>8) == SSL3_VERSION_MAJOR)
246                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[2]));
247                 else 
248                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[1]));
249                 if (ret->cipher == NULL)
250                         return(0);
251                 }
252
253         /* If a thread got the session, then 'swaped', and another got
254          * it and then due to a time-out decided to 'Free' it we could
255          * be in trouble.  So I'll increment it now, then double decrement
256          * later - am I speaking rubbish?. */
257         CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
258
259         if ((long)(ret->time+ret->timeout) < (long)time(NULL)) /* timeout */
260                 {
261                 s->ctx->sess_timeout++;
262                 /* remove it from the cache */
263                 SSL_CTX_remove_session(s->ctx,ret);
264                 SSL_SESSION_free(ret);          /* again to actually Free it */
265                 return(0);
266                 }
267
268         s->ctx->sess_hit++;
269
270         /* ret->time=time(NULL); */ /* rezero timeout? */
271         /* again, just leave the session 
272          * if it is the same session, we have just incremented and
273          * then decremented the reference count :-) */
274         if (s->session != NULL)
275                 SSL_SESSION_free(s->session);
276         s->session=ret;
277         return(1);
278         }
279
280 int SSL_CTX_add_session(ctx,c)
281 SSL_CTX *ctx;
282 SSL_SESSION *c;
283         {
284         int ret=0;
285         SSL_SESSION *s;
286
287         /* conn_init(); */
288         CRYPTO_add(&c->references,1,CRYPTO_LOCK_SSL_SESSION);
289
290         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
291         s=(SSL_SESSION *)lh_insert(ctx->sessions,(char *)c);
292         
293         /* Put on the end of the queue unless it is already in the cache */
294         if (s == NULL)
295                 SSL_SESSION_list_add(ctx,c);
296
297         /* If the same session if is being 're-added', Free the old
298          * one when the last person stops using it.
299          * This will also work if it is alread in the cache.
300          * The references will go up and then down :-) */
301         if (s != NULL)
302                 {
303                 SSL_SESSION_free(s);
304                 ret=0;
305                 }
306         else
307                 {
308                 ret=1;
309
310                 if (SSL_CTX_sess_get_cache_size(ctx) > 0)
311                         {
312                         while (SSL_CTX_sess_number(ctx) >
313                                 SSL_CTX_sess_get_cache_size(ctx))
314                                 {
315                                 if (!SSL_CTX_remove_session(ctx,
316                                         ctx->session_cache_tail))
317                                         break;
318                                 else
319                                         ctx->sess_cache_full++;
320                                 }
321                         }
322                 }
323         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
324         return(ret);
325         }
326
327 int SSL_CTX_remove_session(ctx,c)
328 SSL_CTX *ctx;
329 SSL_SESSION *c;
330         {
331         SSL_SESSION *r;
332         int ret=0;
333
334         if ((c != NULL) && (c->session_id_length != 0))
335                 {
336                 CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
337                 r=(SSL_SESSION *)lh_delete(ctx->sessions,(char *)c);
338                 if (r != NULL)
339                         {
340                         ret=1;
341                         SSL_SESSION_list_remove(ctx,c);
342                         }
343
344                 CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
345
346                 if (ret)
347                         {
348                         r->not_resumable=1;
349                         if (ctx->remove_session_cb != NULL)
350                                 ctx->remove_session_cb(ctx,r);
351                         SSL_SESSION_free(r);
352                         }
353                 }
354         else
355                 ret=0;
356         return(ret);
357         }
358
359 void SSL_SESSION_free(ss)
360 SSL_SESSION *ss;
361         {
362         int i;
363
364         i=CRYPTO_add(&ss->references,-1,CRYPTO_LOCK_SSL_SESSION);
365 #ifdef REF_PRINT
366         REF_PRINT("SSL_SESSION",ss);
367 #endif
368         if (i > 0) return;
369 #ifdef REF_CHECK
370         if (i < 0)
371                 {
372                 fprintf(stderr,"SSL_SESSION_free, bad reference count\n");
373                 abort(); /* ok */
374                 }
375 #endif
376
377         CRYPTO_free_ex_data(ssl_session_meth,(char *)ss,&ss->ex_data);
378
379         memset(ss->key_arg,0,SSL_MAX_KEY_ARG_LENGTH);
380         memset(ss->master_key,0,SSL_MAX_MASTER_KEY_LENGTH);
381         memset(ss->session_id,0,SSL_MAX_SSL_SESSION_ID_LENGTH);
382         if (ss->cert != NULL) ssl_cert_free(ss->cert);
383         if (ss->peer != NULL) X509_free(ss->peer);
384         if (ss->ciphers != NULL) sk_free(ss->ciphers);
385         memset(ss,0,sizeof(*ss));
386         Free(ss);
387         }
388
389 int SSL_set_session(s, session)
390 SSL *s;
391 SSL_SESSION *session;
392         {
393         int ret=0;
394         SSL_METHOD *meth;
395
396         if (session != NULL)
397                 {
398                 meth=s->ctx->method->get_ssl_method(session->ssl_version);
399                 if (meth == NULL)
400                         meth=s->method->get_ssl_method(session->ssl_version);
401                 if (meth == NULL)
402                         {
403                         SSLerr(SSL_F_SSL_SET_SESSION,SSL_R_UNABLE_TO_FIND_SSL_METHOD);
404                         return(0);
405                         }
406
407                 if (meth != s->method)
408                         {
409                         if (!SSL_set_ssl_method(s,meth))
410                                 return(0);
411                         session->timeout=SSL_get_default_timeout(s);
412                         }
413
414                 /* CRYPTO_w_lock(CRYPTO_LOCK_SSL);*/
415                 CRYPTO_add(&session->references,1,CRYPTO_LOCK_SSL_SESSION);
416                 if (s->session != NULL)
417                         SSL_SESSION_free(s->session);
418                 s->session=session;
419                 /* CRYPTO_w_unlock(CRYPTO_LOCK_SSL);*/
420                 ret=1;
421                 }
422         else
423                 {
424                 if (s->session != NULL)
425                         {
426                         SSL_SESSION_free(s->session);
427                         s->session=NULL;
428                         }
429                 }
430         return(ret);
431         }
432
433 long SSL_SESSION_set_timeout(s,t)
434 SSL_SESSION *s;
435 long t;
436         {
437         if (s == NULL) return(0);
438         s->timeout=t;
439         return(1);
440         }
441
442 long SSL_SESSION_get_timeout(s)
443 SSL_SESSION *s;
444         {
445         if (s == NULL) return(0);
446         return(s->timeout);
447         }
448
449 long SSL_SESSION_get_time(s)
450 SSL_SESSION *s;
451         {
452         if (s == NULL) return(0);
453         return(s->time);
454         }
455
456 long SSL_SESSION_set_time(s,t)
457 SSL_SESSION *s;
458 long t;
459         {
460         if (s == NULL) return(0);
461         s->time=t;
462         return(t);
463         }
464
465 typedef struct timeout_param_st
466         {
467         SSL_CTX *ctx;
468         long time;
469         LHASH *cache;
470         } TIMEOUT_PARAM;
471
472 static void timeout(s,p)
473 SSL_SESSION *s;
474 TIMEOUT_PARAM *p;
475         {
476         if ((p->time == 0) || (p->time > (s->time+s->timeout))) /* timeout */
477                 {
478                 /* The reason we don't call SSL_CTX_remove_session() is to
479                  * save on locking overhead */
480                 lh_delete(p->cache,(char *)s);
481                 SSL_SESSION_list_remove(p->ctx,s);
482                 s->not_resumable=1;
483                 if (p->ctx->remove_session_cb != NULL)
484                         p->ctx->remove_session_cb(p->ctx,s);
485                 SSL_SESSION_free(s);
486                 }
487         }
488
489 void SSL_CTX_flush_sessions(s,t)
490 SSL_CTX *s;
491 long t;
492         {
493         unsigned long i;
494         TIMEOUT_PARAM tp;
495
496         tp.ctx=s;
497         tp.cache=SSL_CTX_sessions(s);
498         if (tp.cache == NULL) return;
499         tp.time=t;
500         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
501         i=tp.cache->down_load;
502         tp.cache->down_load=0;
503         lh_doall_arg(tp.cache,(void (*)())timeout,(char *)&tp);
504         tp.cache->down_load=i;
505         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
506         }
507
508 int ssl_clear_bad_session(s)
509 SSL *s;
510         {
511         if (    (s->session != NULL) &&
512                 !(s->shutdown & SSL_SENT_SHUTDOWN) &&
513                 !(SSL_in_init(s) || SSL_in_before(s)))
514                 {
515                 SSL_CTX_remove_session(s->ctx,s->session);
516                 return(1);
517                 }
518         else
519                 return(0);
520         }
521
522 /* locked by SSL_CTX in the calling function */
523 static void SSL_SESSION_list_remove(ctx,s)
524 SSL_CTX *ctx;
525 SSL_SESSION *s;
526         {
527         if ((s->next == NULL) || (s->prev == NULL)) return;
528
529         if (s->next == (SSL_SESSION *)&(ctx->session_cache_tail))
530                 { /* last element in list */
531                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
532                         { /* only one element in list */
533                         ctx->session_cache_head=NULL;
534                         ctx->session_cache_tail=NULL;
535                         }
536                 else
537                         {
538                         ctx->session_cache_tail=s->prev;
539                         s->prev->next=(SSL_SESSION *)&(ctx->session_cache_tail);
540                         }
541                 }
542         else
543                 {
544                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
545                         { /* first element in list */
546                         ctx->session_cache_head=s->next;
547                         s->next->prev=(SSL_SESSION *)&(ctx->session_cache_head);
548                         }
549                 else
550                         { /* middle of list */
551                         s->next->prev=s->prev;
552                         s->prev->next=s->next;
553                         }
554                 }
555         s->prev=s->next=NULL;
556         }
557
558 static void SSL_SESSION_list_add(ctx,s)
559 SSL_CTX *ctx;
560 SSL_SESSION *s;
561         {
562         if ((s->next != NULL) && (s->prev != NULL))
563                 SSL_SESSION_list_remove(ctx,s);
564
565         if (ctx->session_cache_head == NULL)
566                 {
567                 ctx->session_cache_head=s;
568                 ctx->session_cache_tail=s;
569                 s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
570                 s->next=(SSL_SESSION *)&(ctx->session_cache_tail);
571                 }
572         else
573                 {
574                 s->next=ctx->session_cache_head;
575                 s->next->prev=s;
576                 s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
577                 ctx->session_cache_head=s;
578                 }
579         }
580