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