e918d9854f19a82a2265de1c088c89f23cdb3cc8
[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         /* This gets used by clients and servers. */
119
120         SSL_SESSION *ss=NULL;
121
122         if ((ss=SSL_SESSION_new()) == NULL) return(0);
123
124         /* If the context has a default timeout, use it */
125         if (s->ctx->session_timeout == 0)
126                 ss->timeout=SSL_get_default_timeout(s);
127         else
128                 ss->timeout=s->ctx->session_timeout;
129
130         if (s->session != NULL)
131                 {
132                 SSL_SESSION_free(s->session);
133                 s->session=NULL;
134                 }
135
136         if (session)
137                 {
138                 if (s->version == SSL2_VERSION)
139                         {
140                         ss->ssl_version=SSL2_VERSION;
141                         ss->session_id_length=SSL2_SSL_SESSION_ID_LENGTH;
142                         }
143                 else if (s->version == SSL3_VERSION)
144                         {
145                         ss->ssl_version=SSL3_VERSION;
146                         ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
147                         }
148                 else if (s->version == TLS1_VERSION)
149                         {
150                         ss->ssl_version=TLS1_VERSION;
151                         ss->session_id_length=SSL3_SSL_SESSION_ID_LENGTH;
152                         }
153                 else
154                         {
155                         SSLerr(SSL_F_SSL_GET_NEW_SESSION,SSL_R_UNSUPPORTED_SSL_VERSION);
156                         SSL_SESSION_free(ss);
157                         return(0);
158                         }
159
160                 for (;;)
161                         {
162                         SSL_SESSION *r;
163
164                         RAND_bytes(ss->session_id,ss->session_id_length);
165                         CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
166                         r=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,
167                                 (char *)ss);
168                         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
169                         if (r == NULL) break;
170                         /* else - woops a session_id match */
171                         /* XXX should also check external cache!
172                          * (But the probability of a collision is negligible, anyway...) */
173                         }
174                 }
175         else
176                 {
177                 ss->session_id_length=0;
178                 }
179
180         memcpy(ss->sid_ctx,s->sid_ctx,s->sid_ctx_length);
181         ss->sid_ctx_length=s->sid_ctx_length;
182         s->session=ss;
183         ss->ssl_version=s->version;
184
185         return(1);
186         }
187
188 int ssl_get_prev_session(SSL *s, unsigned char *session_id, int len)
189         {
190         /* This is used only by servers. */
191
192         SSL_SESSION *ret=NULL,data;
193         int fatal = 0;
194
195         /* conn_init();*/
196         data.ssl_version=s->version;
197         data.session_id_length=len;
198         if (len > SSL_MAX_SSL_SESSION_ID_LENGTH)
199                 goto err;
200         memcpy(data.session_id,session_id,len);
201
202         if (!(s->ctx->session_cache_mode & SSL_SESS_CACHE_NO_INTERNAL_LOOKUP))
203                 {
204                 CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
205                 ret=(SSL_SESSION *)lh_retrieve(s->ctx->sessions,(char *)&data);
206                 /* don't allow other threads to steal it: */
207                 CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
208                 CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
209                 }
210
211         if (ret == NULL)
212                 {
213                 int copy=1;
214         
215                 s->ctx->stats.sess_miss++;
216                 ret=NULL;
217                 if (s->ctx->get_session_cb != NULL
218                     && (ret=s->ctx->get_session_cb(s,session_id,len,&copy))
219                        != NULL)
220                         {
221                         s->ctx->stats.sess_cb_hit++;
222
223                         /* Increment reference count now if the session callback
224                          * asks us to do so (note that if the session structures
225                          * returned by the callback are shared between threads,
226                          * it must handle the reference count itself [i.e. copy == 0],
227                          * or things won't be thread-safe). */
228                         if (copy)
229                                 CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
230
231                         /* The following should not return 1, otherwise,
232                          * things are very strange */
233                         SSL_CTX_add_session(s->ctx,ret);
234                         }
235                 if (ret == NULL)
236                         goto err;
237                 }
238
239         /* Now ret is non-NULL, and we own one of its reference counts. */
240
241         if((s->verify_mode&SSL_VERIFY_PEER)
242            && (!s->sid_ctx_length || ret->sid_ctx_length != s->sid_ctx_length
243                || memcmp(ret->sid_ctx,s->sid_ctx,ret->sid_ctx_length)))
244             {
245                 /* We've found the session named by the client, but we don't
246                  * want to use it in this context. */
247                 
248                 if (s->sid_ctx_length == 0)
249                         {
250                         /* application should have used SSL[_CTX]_set_session_id_context
251                          * -- we could tolerate this and just pretend we never heard
252                          * of this session, but then applications could effectively
253                          * disable the session cache by accident without anyone noticing */
254
255                         SSLerr(SSL_F_SSL_GET_PREV_SESSION,SSL_R_SESSION_ID_CONTEXT_UNINITIALIZED);
256                         fatal = 1;
257                         goto err;
258                         }
259                 else
260                         {
261 #if 0 /* The client cannot always know when a session is not appropriate,
262            * so we shouldn't generate an error message. */
263
264                         SSLerr(SSL_F_SSL_GET_PREV_SESSION,SSL_R_ATTEMPT_TO_REUSE_SESSION_IN_DIFFERENT_CONTEXT);
265 #endif
266                         goto err; /* treat like cache miss */
267                         }
268                 }
269
270         if (ret->cipher == NULL)
271                 {
272                 unsigned char buf[5],*p;
273                 unsigned long l;
274
275                 p=buf;
276                 l=ret->cipher_id;
277                 l2n(l,p);
278                 if ((ret->ssl_version>>8) == SSL3_VERSION_MAJOR)
279                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[2]));
280                 else 
281                         ret->cipher=ssl_get_cipher_by_char(s,&(buf[1]));
282                 if (ret->cipher == NULL)
283                         goto err;
284                 }
285
286
287 #if 0 /* This is way too late. */
288
289         /* If a thread got the session, then 'swaped', and another got
290          * it and then due to a time-out decided to 'Free' it we could
291          * be in trouble.  So I'll increment it now, then double decrement
292          * later - am I speaking rubbish?. */
293         CRYPTO_add(&ret->references,1,CRYPTO_LOCK_SSL_SESSION);
294 #endif
295
296         if ((long)(ret->time+ret->timeout) < (long)time(NULL)) /* timeout */
297                 {
298                 s->ctx->stats.sess_timeout++;
299                 /* remove it from the cache */
300                 SSL_CTX_remove_session(s->ctx,ret);
301                 goto err;
302                 }
303
304         s->ctx->stats.sess_hit++;
305
306         /* ret->time=time(NULL); */ /* rezero timeout? */
307         /* again, just leave the session 
308          * if it is the same session, we have just incremented and
309          * then decremented the reference count :-) */
310         if (s->session != NULL)
311                 SSL_SESSION_free(s->session);
312         s->session=ret;
313         return(1);
314
315  err:
316         if (ret != NULL)
317                 SSL_SESSION_free(ret);
318         if (fatal)
319                 return -1;
320         else
321                 return 0;
322         }
323
324 int SSL_CTX_add_session(SSL_CTX *ctx, SSL_SESSION *c)
325         {
326         int ret=0;
327         SSL_SESSION *s;
328
329         /* conn_init(); */
330         CRYPTO_add(&c->references,1,CRYPTO_LOCK_SSL_SESSION);
331
332         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
333         s=(SSL_SESSION *)lh_insert(ctx->sessions,(char *)c);
334         
335         /* Put on the end of the queue unless it is already in the cache */
336         if (s == NULL)
337                 SSL_SESSION_list_add(ctx,c);
338
339         /* If the same session if is being 're-added', Free the old
340          * one when the last person stops using it.
341          * This will also work if it is alread in the cache.
342          * The references will go up and then down :-) */
343         if (s != NULL)
344                 {
345                 SSL_SESSION_free(s);
346                 ret=0;
347                 }
348         else
349                 {
350                 ret=1;
351
352                 if (SSL_CTX_sess_get_cache_size(ctx) > 0)
353                         {
354                         while (SSL_CTX_sess_number(ctx) >
355                                 SSL_CTX_sess_get_cache_size(ctx))
356                                 {
357                                 if (!remove_session_lock(ctx,
358                                         ctx->session_cache_tail, 0))
359                                         break;
360                                 else
361                                         ctx->stats.sess_cache_full++;
362                                 }
363                         }
364                 }
365         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
366         return(ret);
367         }
368
369 int SSL_CTX_remove_session(SSL_CTX *ctx, SSL_SESSION *c)
370 {
371         return remove_session_lock(ctx, c, 1);
372 }
373
374 static int remove_session_lock(SSL_CTX *ctx, SSL_SESSION *c, int lck)
375         {
376         SSL_SESSION *r;
377         int ret=0;
378
379         if ((c != NULL) && (c->session_id_length != 0))
380                 {
381                 if(lck) CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
382                 r=(SSL_SESSION *)lh_delete(ctx->sessions,(char *)c);
383                 if (r != NULL)
384                         {
385                         ret=1;
386                         SSL_SESSION_list_remove(ctx,c);
387                         }
388
389                 if(lck) CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
390
391                 if (ret)
392                         {
393                         r->not_resumable=1;
394                         if (ctx->remove_session_cb != NULL)
395                                 ctx->remove_session_cb(ctx,r);
396                         SSL_SESSION_free(r);
397                         }
398                 }
399         else
400                 ret=0;
401         return(ret);
402         }
403
404 void SSL_SESSION_free(SSL_SESSION *ss)
405         {
406         int i;
407
408         if(ss == NULL)
409             return;
410
411         i=CRYPTO_add(&ss->references,-1,CRYPTO_LOCK_SSL_SESSION);
412 #ifdef REF_PRINT
413         REF_PRINT("SSL_SESSION",ss);
414 #endif
415         if (i > 0) return;
416 #ifdef REF_CHECK
417         if (i < 0)
418                 {
419                 fprintf(stderr,"SSL_SESSION_free, bad reference count\n");
420                 abort(); /* ok */
421                 }
422 #endif
423
424         CRYPTO_free_ex_data(ssl_session_meth,(char *)ss,&ss->ex_data);
425
426         memset(ss->key_arg,0,SSL_MAX_KEY_ARG_LENGTH);
427         memset(ss->master_key,0,SSL_MAX_MASTER_KEY_LENGTH);
428         memset(ss->session_id,0,SSL_MAX_SSL_SESSION_ID_LENGTH);
429         if (ss->sess_cert != NULL) ssl_sess_cert_free(ss->sess_cert);
430         if (ss->peer != NULL) X509_free(ss->peer);
431         if (ss->ciphers != NULL) sk_SSL_CIPHER_free(ss->ciphers);
432         memset(ss,0,sizeof(*ss));
433         Free(ss);
434         }
435
436 int SSL_set_session(SSL *s, SSL_SESSION *session)
437         {
438         int ret=0;
439         SSL_METHOD *meth;
440
441         if (session != NULL)
442                 {
443                 meth=s->ctx->method->get_ssl_method(session->ssl_version);
444                 if (meth == NULL)
445                         meth=s->method->get_ssl_method(session->ssl_version);
446                 if (meth == NULL)
447                         {
448                         SSLerr(SSL_F_SSL_SET_SESSION,SSL_R_UNABLE_TO_FIND_SSL_METHOD);
449                         return(0);
450                         }
451
452                 if (meth != s->method)
453                         {
454                         if (!SSL_set_ssl_method(s,meth))
455                                 return(0);
456                         if (s->ctx->session_timeout == 0)
457                                 session->timeout=SSL_get_default_timeout(s);
458                         else
459                                 session->timeout=s->ctx->session_timeout;
460                         }
461
462                 /* CRYPTO_w_lock(CRYPTO_LOCK_SSL);*/
463                 CRYPTO_add(&session->references,1,CRYPTO_LOCK_SSL_SESSION);
464                 if (s->session != NULL)
465                         SSL_SESSION_free(s->session);
466                 s->session=session;
467                 /* CRYPTO_w_unlock(CRYPTO_LOCK_SSL);*/
468                 ret=1;
469                 }
470         else
471                 {
472                 if (s->session != NULL)
473                         {
474                         SSL_SESSION_free(s->session);
475                         s->session=NULL;
476                         }
477
478                 meth=s->ctx->method;
479                 if (meth != s->method)
480                         {
481                         if (!SSL_set_ssl_method(s,meth))
482                                 return(0);
483                         }
484                 ret=1;
485                 }
486         return(ret);
487         }
488
489 long SSL_SESSION_set_timeout(SSL_SESSION *s, long t)
490         {
491         if (s == NULL) return(0);
492         s->timeout=t;
493         return(1);
494         }
495
496 long SSL_SESSION_get_timeout(SSL_SESSION *s)
497         {
498         if (s == NULL) return(0);
499         return(s->timeout);
500         }
501
502 long SSL_SESSION_get_time(SSL_SESSION *s)
503         {
504         if (s == NULL) return(0);
505         return(s->time);
506         }
507
508 long SSL_SESSION_set_time(SSL_SESSION *s, long t)
509         {
510         if (s == NULL) return(0);
511         s->time=t;
512         return(t);
513         }
514
515 long SSL_CTX_set_timeout(SSL_CTX *s, long t)
516         {
517         long l;
518         if (s == NULL) return(0);
519         l=s->session_timeout;
520         s->session_timeout=t;
521         return(l);
522         }
523
524 long SSL_CTX_get_timeout(SSL_CTX *s)
525         {
526         if (s == NULL) return(0);
527         return(s->session_timeout);
528         }
529
530 typedef struct timeout_param_st
531         {
532         SSL_CTX *ctx;
533         long time;
534         LHASH *cache;
535         } TIMEOUT_PARAM;
536
537 static void timeout(SSL_SESSION *s, TIMEOUT_PARAM *p)
538         {
539         if ((p->time == 0) || (p->time > (s->time+s->timeout))) /* timeout */
540                 {
541                 /* The reason we don't call SSL_CTX_remove_session() is to
542                  * save on locking overhead */
543                 lh_delete(p->cache,(char *)s);
544                 SSL_SESSION_list_remove(p->ctx,s);
545                 s->not_resumable=1;
546                 if (p->ctx->remove_session_cb != NULL)
547                         p->ctx->remove_session_cb(p->ctx,s);
548                 SSL_SESSION_free(s);
549                 }
550         }
551
552 void SSL_CTX_flush_sessions(SSL_CTX *s, long t)
553         {
554         unsigned long i;
555         TIMEOUT_PARAM tp;
556
557         tp.ctx=s;
558         tp.cache=s->sessions;
559         if (tp.cache == NULL) return;
560         tp.time=t;
561         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
562         i=tp.cache->down_load;
563         tp.cache->down_load=0;
564         lh_doall_arg(tp.cache,(void (*)())timeout,(char *)&tp);
565         tp.cache->down_load=i;
566         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
567         }
568
569 int ssl_clear_bad_session(SSL *s)
570         {
571         if (    (s->session != NULL) &&
572                 !(s->shutdown & SSL_SENT_SHUTDOWN) &&
573                 !(SSL_in_init(s) || SSL_in_before(s)))
574                 {
575                 SSL_CTX_remove_session(s->ctx,s->session);
576                 return(1);
577                 }
578         else
579                 return(0);
580         }
581
582 /* locked by SSL_CTX in the calling function */
583 static void SSL_SESSION_list_remove(SSL_CTX *ctx, SSL_SESSION *s)
584         {
585         if ((s->next == NULL) || (s->prev == NULL)) return;
586
587         if (s->next == (SSL_SESSION *)&(ctx->session_cache_tail))
588                 { /* last element in list */
589                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
590                         { /* only one element in list */
591                         ctx->session_cache_head=NULL;
592                         ctx->session_cache_tail=NULL;
593                         }
594                 else
595                         {
596                         ctx->session_cache_tail=s->prev;
597                         s->prev->next=(SSL_SESSION *)&(ctx->session_cache_tail);
598                         }
599                 }
600         else
601                 {
602                 if (s->prev == (SSL_SESSION *)&(ctx->session_cache_head))
603                         { /* first element in list */
604                         ctx->session_cache_head=s->next;
605                         s->next->prev=(SSL_SESSION *)&(ctx->session_cache_head);
606                         }
607                 else
608                         { /* middle of list */
609                         s->next->prev=s->prev;
610                         s->prev->next=s->next;
611                         }
612                 }
613         s->prev=s->next=NULL;
614         }
615
616 static void SSL_SESSION_list_add(SSL_CTX *ctx, SSL_SESSION *s)
617         {
618         if ((s->next != NULL) && (s->prev != NULL))
619                 SSL_SESSION_list_remove(ctx,s);
620
621         if (ctx->session_cache_head == NULL)
622                 {
623                 ctx->session_cache_head=s;
624                 ctx->session_cache_tail=s;
625                 s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
626                 s->next=(SSL_SESSION *)&(ctx->session_cache_tail);
627                 }
628         else
629                 {
630                 s->next=ctx->session_cache_head;
631                 s->next->prev=s;
632                 s->prev=(SSL_SESSION *)&(ctx->session_cache_head);
633                 ctx->session_cache_head=s;
634                 }
635         }
636