Typo
[openssl.git] / ssl / ssl_lib.c
1 /*! \file ssl/ssl_lib.c
2  *  \brief Version independent SSL functions.
3  */
4 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
5  * All rights reserved.
6  *
7  * This package is an SSL implementation written
8  * by Eric Young (eay@cryptsoft.com).
9  * The implementation was written so as to conform with Netscapes SSL.
10  * 
11  * This library is free for commercial and non-commercial use as long as
12  * the following conditions are aheared to.  The following conditions
13  * apply to all code found in this distribution, be it the RC4, RSA,
14  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
15  * included with this distribution is covered by the same copyright terms
16  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
17  * 
18  * Copyright remains Eric Young's, and as such any Copyright notices in
19  * the code are not to be removed.
20  * If this package is used in a product, Eric Young should be given attribution
21  * as the author of the parts of the library used.
22  * This can be in the form of a textual message at program startup or
23  * in documentation (online or textual) provided with the package.
24  * 
25  * Redistribution and use in source and binary forms, with or without
26  * modification, are permitted provided that the following conditions
27  * are met:
28  * 1. Redistributions of source code must retain the copyright
29  *    notice, this list of conditions and the following disclaimer.
30  * 2. Redistributions in binary form must reproduce the above copyright
31  *    notice, this list of conditions and the following disclaimer in the
32  *    documentation and/or other materials provided with the distribution.
33  * 3. All advertising materials mentioning features or use of this software
34  *    must display the following acknowledgement:
35  *    "This product includes cryptographic software written by
36  *     Eric Young (eay@cryptsoft.com)"
37  *    The word 'cryptographic' can be left out if the rouines from the library
38  *    being used are not cryptographic related :-).
39  * 4. If you include any Windows specific code (or a derivative thereof) from 
40  *    the apps directory (application code) you must include an acknowledgement:
41  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
42  * 
43  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  * 
55  * The licence and distribution terms for any publically available version or
56  * derivative of this code cannot be changed.  i.e. this code cannot simply be
57  * copied and put under another distribution licence
58  * [including the GNU Public Licence.]
59  */
60 /* ====================================================================
61  * Copyright (c) 1998-2007 The OpenSSL Project.  All rights reserved.
62  *
63  * Redistribution and use in source and binary forms, with or without
64  * modification, are permitted provided that the following conditions
65  * are met:
66  *
67  * 1. Redistributions of source code must retain the above copyright
68  *    notice, this list of conditions and the following disclaimer. 
69  *
70  * 2. Redistributions in binary form must reproduce the above copyright
71  *    notice, this list of conditions and the following disclaimer in
72  *    the documentation and/or other materials provided with the
73  *    distribution.
74  *
75  * 3. All advertising materials mentioning features or use of this
76  *    software must display the following acknowledgment:
77  *    "This product includes software developed by the OpenSSL Project
78  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
79  *
80  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
81  *    endorse or promote products derived from this software without
82  *    prior written permission. For written permission, please contact
83  *    openssl-core@openssl.org.
84  *
85  * 5. Products derived from this software may not be called "OpenSSL"
86  *    nor may "OpenSSL" appear in their names without prior written
87  *    permission of the OpenSSL Project.
88  *
89  * 6. Redistributions of any form whatsoever must retain the following
90  *    acknowledgment:
91  *    "This product includes software developed by the OpenSSL Project
92  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
93  *
94  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
95  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
96  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
97  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
98  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
99  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
100  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
101  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
102  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
103  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
104  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
105  * OF THE POSSIBILITY OF SUCH DAMAGE.
106  * ====================================================================
107  *
108  * This product includes cryptographic software written by Eric Young
109  * (eay@cryptsoft.com).  This product includes software written by Tim
110  * Hudson (tjh@cryptsoft.com).
111  *
112  */
113 /* ====================================================================
114  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
115  * ECC cipher suite support in OpenSSL originally developed by 
116  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
117  */
118 /* ====================================================================
119  * Copyright 2005 Nokia. All rights reserved.
120  *
121  * The portions of the attached software ("Contribution") is developed by
122  * Nokia Corporation and is licensed pursuant to the OpenSSL open source
123  * license.
124  *
125  * The Contribution, originally written by Mika Kousa and Pasi Eronen of
126  * Nokia Corporation, consists of the "PSK" (Pre-Shared Key) ciphersuites
127  * support (see RFC 4279) to OpenSSL.
128  *
129  * No patent licenses or other rights except those expressly stated in
130  * the OpenSSL open source license shall be deemed granted or received
131  * expressly, by implication, estoppel, or otherwise.
132  *
133  * No assurances are provided by Nokia that the Contribution does not
134  * infringe the patent or other intellectual property rights of any third
135  * party or that the license provides you with all the necessary rights
136  * to make use of the Contribution.
137  *
138  * THE SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. IN
139  * ADDITION TO THE DISCLAIMERS INCLUDED IN THE LICENSE, NOKIA
140  * SPECIFICALLY DISCLAIMS ANY LIABILITY FOR CLAIMS BROUGHT BY YOU OR ANY
141  * OTHER ENTITY BASED ON INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS OR
142  * OTHERWISE.
143  */
144
145 #ifdef REF_CHECK
146 #  include <assert.h>
147 #endif
148 #include <stdio.h>
149 #include "ssl_locl.h"
150 #include "kssl_lcl.h"
151 #include <openssl/objects.h>
152 #include <openssl/lhash.h>
153 #include <openssl/x509v3.h>
154 #include <openssl/rand.h>
155 #include <openssl/ocsp.h>
156 #ifndef OPENSSL_NO_DH
157 #include <openssl/dh.h>
158 #endif
159 #ifndef OPENSSL_NO_ENGINE
160 #include <openssl/engine.h>
161 #endif
162
163 const char *SSL_version_str=OPENSSL_VERSION_TEXT;
164
165 SSL3_ENC_METHOD ssl3_undef_enc_method={
166         /* evil casts, but these functions are only called if there's a library bug */
167         (int (*)(SSL *,int))ssl_undefined_function,
168         (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
169         ssl_undefined_function,
170         (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
171         (int (*)(SSL*, int))ssl_undefined_function,
172         (int (*)(SSL *,  const char*, int, unsigned char *))ssl_undefined_function,
173         0,      /* finish_mac_length */
174         (int (*)(SSL *, int, unsigned char *))ssl_undefined_function,
175         NULL,   /* client_finished_label */
176         0,      /* client_finished_label_len */
177         NULL,   /* server_finished_label */
178         0,      /* server_finished_label_len */
179         (int (*)(int))ssl_undefined_function
180         };
181
182 int SSL_clear(SSL *s)
183         {
184
185         if (s->method == NULL)
186                 {
187                 SSLerr(SSL_F_SSL_CLEAR,SSL_R_NO_METHOD_SPECIFIED);
188                 return(0);
189                 }
190
191         if (ssl_clear_bad_session(s))
192                 {
193                 SSL_SESSION_free(s->session);
194                 s->session=NULL;
195                 }
196
197         s->error=0;
198         s->hit=0;
199         s->shutdown=0;
200
201 #if 0 /* Disabled since version 1.10 of this file (early return not
202        * needed because SSL_clear is not called when doing renegotiation) */
203         /* This is set if we are doing dynamic renegotiation so keep
204          * the old cipher.  It is sort of a SSL_clear_lite :-) */
205         if (s->new_session) return(1);
206 #else
207         if (s->new_session)
208                 {
209                 SSLerr(SSL_F_SSL_CLEAR,ERR_R_INTERNAL_ERROR);
210                 return 0;
211                 }
212 #endif
213
214         s->type=0;
215
216         s->state=SSL_ST_BEFORE|((s->server)?SSL_ST_ACCEPT:SSL_ST_CONNECT);
217
218         s->version=s->method->version;
219         s->client_version=s->version;
220         s->rwstate=SSL_NOTHING;
221         s->rstate=SSL_ST_READ_HEADER;
222 #if 0
223         s->read_ahead=s->ctx->read_ahead;
224 #endif
225
226         if (s->init_buf != NULL)
227                 {
228                 BUF_MEM_free(s->init_buf);
229                 s->init_buf=NULL;
230                 }
231
232         ssl_clear_cipher_ctx(s);
233         ssl_clear_hash_ctx(&s->read_hash);
234         ssl_clear_hash_ctx(&s->write_hash);
235
236         s->first_packet=0;
237
238 #if 1
239         /* Check to see if we were changed into a different method, if
240          * so, revert back if we are not doing session-id reuse. */
241         if (!s->in_handshake && (s->session == NULL) && (s->method != s->ctx->method))
242                 {
243                 s->method->ssl_free(s);
244                 s->method=s->ctx->method;
245                 if (!s->method->ssl_new(s))
246                         return(0);
247                 }
248         else
249 #endif
250                 s->method->ssl_clear(s);
251         return(1);
252         }
253
254 /** Used to change an SSL_CTXs default SSL method type */
255 int SSL_CTX_set_ssl_version(SSL_CTX *ctx,const SSL_METHOD *meth)
256         {
257         STACK_OF(SSL_CIPHER) *sk;
258
259         ctx->method=meth;
260
261         sk=ssl_create_cipher_list(ctx->method,&(ctx->cipher_list),
262                 &(ctx->cipher_list_by_id),
263                 meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST);
264         if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= 0))
265                 {
266                 SSLerr(SSL_F_SSL_CTX_SET_SSL_VERSION,SSL_R_SSL_LIBRARY_HAS_NO_CIPHERS);
267                 return(0);
268                 }
269         return(1);
270         }
271
272 SSL *SSL_new(SSL_CTX *ctx)
273         {
274         SSL *s;
275
276         if (ctx == NULL)
277                 {
278                 SSLerr(SSL_F_SSL_NEW,SSL_R_NULL_SSL_CTX);
279                 return(NULL);
280                 }
281         if (ctx->method == NULL)
282                 {
283                 SSLerr(SSL_F_SSL_NEW,SSL_R_SSL_CTX_HAS_NO_DEFAULT_SSL_VERSION);
284                 return(NULL);
285                 }
286
287         s=(SSL *)OPENSSL_malloc(sizeof(SSL));
288         if (s == NULL) goto err;
289         memset(s,0,sizeof(SSL));
290
291 #ifndef OPENSSL_NO_KRB5
292         s->kssl_ctx = kssl_ctx_new();
293 #endif  /* OPENSSL_NO_KRB5 */
294
295         s->options=ctx->options;
296         s->mode=ctx->mode;
297         s->max_cert_list=ctx->max_cert_list;
298
299         if (ctx->cert != NULL)
300                 {
301                 /* Earlier library versions used to copy the pointer to
302                  * the CERT, not its contents; only when setting new
303                  * parameters for the per-SSL copy, ssl_cert_new would be
304                  * called (and the direct reference to the per-SSL_CTX
305                  * settings would be lost, but those still were indirectly
306                  * accessed for various purposes, and for that reason they
307                  * used to be known as s->ctx->default_cert).
308                  * Now we don't look at the SSL_CTX's CERT after having
309                  * duplicated it once. */
310
311                 s->cert = ssl_cert_dup(ctx->cert);
312                 if (s->cert == NULL)
313                         goto err;
314                 }
315         else
316                 s->cert=NULL; /* Cannot really happen (see SSL_CTX_new) */
317
318         s->read_ahead=ctx->read_ahead;
319         s->msg_callback=ctx->msg_callback;
320         s->msg_callback_arg=ctx->msg_callback_arg;
321         s->verify_mode=ctx->verify_mode;
322 #if 0
323         s->verify_depth=ctx->verify_depth;
324 #endif
325         s->sid_ctx_length=ctx->sid_ctx_length;
326         OPENSSL_assert(s->sid_ctx_length <= sizeof s->sid_ctx);
327         memcpy(&s->sid_ctx,&ctx->sid_ctx,sizeof(s->sid_ctx));
328         s->verify_callback=ctx->default_verify_callback;
329         s->generate_session_id=ctx->generate_session_id;
330
331         s->param = X509_VERIFY_PARAM_new();
332         if (!s->param)
333                 goto err;
334         X509_VERIFY_PARAM_inherit(s->param, ctx->param);
335 #if 0
336         s->purpose = ctx->purpose;
337         s->trust = ctx->trust;
338 #endif
339         s->quiet_shutdown=ctx->quiet_shutdown;
340         s->max_send_fragment = ctx->max_send_fragment;
341
342         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
343         s->ctx=ctx;
344 #ifndef OPENSSL_NO_TLSEXT
345         s->tlsext_debug_cb = 0;
346         s->tlsext_debug_arg = NULL;
347         s->tlsext_ticket_expected = 0;
348         s->tlsext_status_type = -1;
349         s->tlsext_status_expected = 0;
350         s->tlsext_ocsp_ids = NULL;
351         s->tlsext_ocsp_exts = NULL;
352         s->tlsext_ocsp_resp = NULL;
353         s->tlsext_ocsp_resplen = -1;
354         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
355         s->initial_ctx=ctx;
356 #endif
357
358         s->verify_result=X509_V_OK;
359
360         s->method=ctx->method;
361
362         if (!s->method->ssl_new(s))
363                 goto err;
364
365         s->references=1;
366         s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
367
368         SSL_clear(s);
369
370         CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
371
372 #ifndef OPENSSL_NO_PSK
373         s->psk_client_callback=ctx->psk_client_callback;
374         s->psk_server_callback=ctx->psk_server_callback;
375 #endif
376
377         return(s);
378 err:
379         if (s != NULL)
380                 {
381                 if (s->cert != NULL)
382                         ssl_cert_free(s->cert);
383                 if (s->ctx != NULL)
384                         SSL_CTX_free(s->ctx); /* decrement reference count */
385                 OPENSSL_free(s);
386                 }
387         SSLerr(SSL_F_SSL_NEW,ERR_R_MALLOC_FAILURE);
388         return(NULL);
389         }
390
391 int SSL_CTX_set_session_id_context(SSL_CTX *ctx,const unsigned char *sid_ctx,
392                                    unsigned int sid_ctx_len)
393     {
394     if(sid_ctx_len > sizeof ctx->sid_ctx)
395         {
396         SSLerr(SSL_F_SSL_CTX_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
397         return 0;
398         }
399     ctx->sid_ctx_length=sid_ctx_len;
400     memcpy(ctx->sid_ctx,sid_ctx,sid_ctx_len);
401
402     return 1;
403     }
404
405 int SSL_set_session_id_context(SSL *ssl,const unsigned char *sid_ctx,
406                                unsigned int sid_ctx_len)
407     {
408     if(sid_ctx_len > SSL_MAX_SID_CTX_LENGTH)
409         {
410         SSLerr(SSL_F_SSL_SET_SESSION_ID_CONTEXT,SSL_R_SSL_SESSION_ID_CONTEXT_TOO_LONG);
411         return 0;
412         }
413     ssl->sid_ctx_length=sid_ctx_len;
414     memcpy(ssl->sid_ctx,sid_ctx,sid_ctx_len);
415
416     return 1;
417     }
418
419 int SSL_CTX_set_generate_session_id(SSL_CTX *ctx, GEN_SESSION_CB cb)
420         {
421         CRYPTO_w_lock(CRYPTO_LOCK_SSL_CTX);
422         ctx->generate_session_id = cb;
423         CRYPTO_w_unlock(CRYPTO_LOCK_SSL_CTX);
424         return 1;
425         }
426
427 int SSL_set_generate_session_id(SSL *ssl, GEN_SESSION_CB cb)
428         {
429         CRYPTO_w_lock(CRYPTO_LOCK_SSL);
430         ssl->generate_session_id = cb;
431         CRYPTO_w_unlock(CRYPTO_LOCK_SSL);
432         return 1;
433         }
434
435 int SSL_has_matching_session_id(const SSL *ssl, const unsigned char *id,
436                                 unsigned int id_len)
437         {
438         /* A quick examination of SSL_SESSION_hash and SSL_SESSION_cmp shows how
439          * we can "construct" a session to give us the desired check - ie. to
440          * find if there's a session in the hash table that would conflict with
441          * any new session built out of this id/id_len and the ssl_version in
442          * use by this SSL. */
443         SSL_SESSION r, *p;
444
445         if(id_len > sizeof r.session_id)
446                 return 0;
447
448         r.ssl_version = ssl->version;
449         r.session_id_length = id_len;
450         memcpy(r.session_id, id, id_len);
451         /* NB: SSLv2 always uses a fixed 16-byte session ID, so even if a
452          * callback is calling us to check the uniqueness of a shorter ID, it
453          * must be compared as a padded-out ID because that is what it will be
454          * converted to when the callback has finished choosing it. */
455         if((r.ssl_version == SSL2_VERSION) &&
456                         (id_len < SSL2_SSL_SESSION_ID_LENGTH))
457                 {
458                 memset(r.session_id + id_len, 0,
459                         SSL2_SSL_SESSION_ID_LENGTH - id_len);
460                 r.session_id_length = SSL2_SSL_SESSION_ID_LENGTH;
461                 }
462
463         CRYPTO_r_lock(CRYPTO_LOCK_SSL_CTX);
464         p = lh_SSL_SESSION_retrieve(ssl->ctx->sessions, &r);
465         CRYPTO_r_unlock(CRYPTO_LOCK_SSL_CTX);
466         return (p != NULL);
467         }
468
469 int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
470         {
471         return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
472         }
473
474 int SSL_set_purpose(SSL *s, int purpose)
475         {
476         return X509_VERIFY_PARAM_set_purpose(s->param, purpose);
477         }
478
479 int SSL_CTX_set_trust(SSL_CTX *s, int trust)
480         {
481         return X509_VERIFY_PARAM_set_trust(s->param, trust);
482         }
483
484 int SSL_set_trust(SSL *s, int trust)
485         {
486         return X509_VERIFY_PARAM_set_trust(s->param, trust);
487         }
488
489 int SSL_CTX_set1_param(SSL_CTX *ctx, X509_VERIFY_PARAM *vpm)
490         {
491         return X509_VERIFY_PARAM_set1(ctx->param, vpm);
492         }
493
494 int SSL_set1_param(SSL *ssl, X509_VERIFY_PARAM *vpm)
495         {
496         return X509_VERIFY_PARAM_set1(ssl->param, vpm);
497         }
498
499 void SSL_free(SSL *s)
500         {
501         int i;
502
503         if(s == NULL)
504             return;
505
506         i=CRYPTO_add(&s->references,-1,CRYPTO_LOCK_SSL);
507 #ifdef REF_PRINT
508         REF_PRINT("SSL",s);
509 #endif
510         if (i > 0) return;
511 #ifdef REF_CHECK
512         if (i < 0)
513                 {
514                 fprintf(stderr,"SSL_free, bad reference count\n");
515                 abort(); /* ok */
516                 }
517 #endif
518
519         if (s->param)
520                 X509_VERIFY_PARAM_free(s->param);
521
522         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL, s, &s->ex_data);
523
524         if (s->bbio != NULL)
525                 {
526                 /* If the buffering BIO is in place, pop it off */
527                 if (s->bbio == s->wbio)
528                         {
529                         s->wbio=BIO_pop(s->wbio);
530                         }
531                 BIO_free(s->bbio);
532                 s->bbio=NULL;
533                 }
534         if (s->rbio != NULL)
535                 BIO_free_all(s->rbio);
536         if ((s->wbio != NULL) && (s->wbio != s->rbio))
537                 BIO_free_all(s->wbio);
538
539         if (s->init_buf != NULL) BUF_MEM_free(s->init_buf);
540
541         /* add extra stuff */
542         if (s->cipher_list != NULL) sk_SSL_CIPHER_free(s->cipher_list);
543         if (s->cipher_list_by_id != NULL) sk_SSL_CIPHER_free(s->cipher_list_by_id);
544
545         /* Make the next call work :-) */
546         if (s->session != NULL)
547                 {
548                 ssl_clear_bad_session(s);
549                 SSL_SESSION_free(s->session);
550                 }
551
552         ssl_clear_cipher_ctx(s);
553         ssl_clear_hash_ctx(&s->read_hash);
554         ssl_clear_hash_ctx(&s->write_hash);
555
556         if (s->cert != NULL) ssl_cert_free(s->cert);
557         /* Free up if allocated */
558
559 #ifndef OPENSSL_NO_TLSEXT
560         if (s->tlsext_hostname)
561                 OPENSSL_free(s->tlsext_hostname);
562         if (s->initial_ctx) SSL_CTX_free(s->initial_ctx);
563 #ifndef OPENSSL_NO_EC
564         if (s->tlsext_ecpointformatlist) OPENSSL_free(s->tlsext_ecpointformatlist);
565         if (s->tlsext_ellipticcurvelist) OPENSSL_free(s->tlsext_ellipticcurvelist);
566 #endif /* OPENSSL_NO_EC */
567         if (s->tlsext_opaque_prf_input) OPENSSL_free(s->tlsext_opaque_prf_input);
568         if (s->tlsext_ocsp_exts)
569                 sk_X509_EXTENSION_pop_free(s->tlsext_ocsp_exts,
570                                                 X509_EXTENSION_free);
571         if (s->tlsext_ocsp_ids)
572                 sk_OCSP_RESPID_pop_free(s->tlsext_ocsp_ids, OCSP_RESPID_free);
573         if (s->tlsext_ocsp_resp)
574                 OPENSSL_free(s->tlsext_ocsp_resp);
575 #endif
576
577         if (s->client_CA != NULL)
578                 sk_X509_NAME_pop_free(s->client_CA,X509_NAME_free);
579
580         if (s->method != NULL) s->method->ssl_free(s);
581
582         if (s->ctx) SSL_CTX_free(s->ctx);
583
584 #ifndef OPENSSL_NO_KRB5
585         if (s->kssl_ctx != NULL)
586                 kssl_ctx_free(s->kssl_ctx);
587 #endif  /* OPENSSL_NO_KRB5 */
588
589         OPENSSL_free(s);
590         }
591
592 void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
593         {
594         /* If the output buffering BIO is still in place, remove it
595          */
596         if (s->bbio != NULL)
597                 {
598                 if (s->wbio == s->bbio)
599                         {
600                         s->wbio=s->wbio->next_bio;
601                         s->bbio->next_bio=NULL;
602                         }
603                 }
604         if ((s->rbio != NULL) && (s->rbio != rbio))
605                 BIO_free_all(s->rbio);
606         if ((s->wbio != NULL) && (s->wbio != wbio) && (s->rbio != s->wbio))
607                 BIO_free_all(s->wbio);
608         s->rbio=rbio;
609         s->wbio=wbio;
610         }
611
612 BIO *SSL_get_rbio(const SSL *s)
613         { return(s->rbio); }
614
615 BIO *SSL_get_wbio(const SSL *s)
616         { return(s->wbio); }
617
618 int SSL_get_fd(const SSL *s)
619         {
620         return(SSL_get_rfd(s));
621         }
622
623 int SSL_get_rfd(const SSL *s)
624         {
625         int ret= -1;
626         BIO *b,*r;
627
628         b=SSL_get_rbio(s);
629         r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
630         if (r != NULL)
631                 BIO_get_fd(r,&ret);
632         return(ret);
633         }
634
635 int SSL_get_wfd(const SSL *s)
636         {
637         int ret= -1;
638         BIO *b,*r;
639
640         b=SSL_get_wbio(s);
641         r=BIO_find_type(b,BIO_TYPE_DESCRIPTOR);
642         if (r != NULL)
643                 BIO_get_fd(r,&ret);
644         return(ret);
645         }
646
647 #ifndef OPENSSL_NO_SOCK
648 int SSL_set_fd(SSL *s,int fd)
649         {
650         int ret=0;
651         BIO *bio=NULL;
652
653         bio=BIO_new(BIO_s_socket());
654
655         if (bio == NULL)
656                 {
657                 SSLerr(SSL_F_SSL_SET_FD,ERR_R_BUF_LIB);
658                 goto err;
659                 }
660         BIO_set_fd(bio,fd,BIO_NOCLOSE);
661         SSL_set_bio(s,bio,bio);
662         ret=1;
663 err:
664         return(ret);
665         }
666
667 int SSL_set_wfd(SSL *s,int fd)
668         {
669         int ret=0;
670         BIO *bio=NULL;
671
672         if ((s->rbio == NULL) || (BIO_method_type(s->rbio) != BIO_TYPE_SOCKET)
673                 || ((int)BIO_get_fd(s->rbio,NULL) != fd))
674                 {
675                 bio=BIO_new(BIO_s_socket());
676
677                 if (bio == NULL)
678                         { SSLerr(SSL_F_SSL_SET_WFD,ERR_R_BUF_LIB); goto err; }
679                 BIO_set_fd(bio,fd,BIO_NOCLOSE);
680                 SSL_set_bio(s,SSL_get_rbio(s),bio);
681                 }
682         else
683                 SSL_set_bio(s,SSL_get_rbio(s),SSL_get_rbio(s));
684         ret=1;
685 err:
686         return(ret);
687         }
688
689 int SSL_set_rfd(SSL *s,int fd)
690         {
691         int ret=0;
692         BIO *bio=NULL;
693
694         if ((s->wbio == NULL) || (BIO_method_type(s->wbio) != BIO_TYPE_SOCKET)
695                 || ((int)BIO_get_fd(s->wbio,NULL) != fd))
696                 {
697                 bio=BIO_new(BIO_s_socket());
698
699                 if (bio == NULL)
700                         {
701                         SSLerr(SSL_F_SSL_SET_RFD,ERR_R_BUF_LIB);
702                         goto err;
703                         }
704                 BIO_set_fd(bio,fd,BIO_NOCLOSE);
705                 SSL_set_bio(s,bio,SSL_get_wbio(s));
706                 }
707         else
708                 SSL_set_bio(s,SSL_get_wbio(s),SSL_get_wbio(s));
709         ret=1;
710 err:
711         return(ret);
712         }
713 #endif
714
715
716 /* return length of latest Finished message we sent, copy to 'buf' */
717 size_t SSL_get_finished(const SSL *s, void *buf, size_t count)
718         {
719         size_t ret = 0;
720         
721         if (s->s3 != NULL)
722                 {
723                 ret = s->s3->tmp.finish_md_len;
724                 if (count > ret)
725                         count = ret;
726                 memcpy(buf, s->s3->tmp.finish_md, count);
727                 }
728         return ret;
729         }
730
731 /* return length of latest Finished message we expected, copy to 'buf' */
732 size_t SSL_get_peer_finished(const SSL *s, void *buf, size_t count)
733         {
734         size_t ret = 0;
735         
736         if (s->s3 != NULL)
737                 {
738                 ret = s->s3->tmp.peer_finish_md_len;
739                 if (count > ret)
740                         count = ret;
741                 memcpy(buf, s->s3->tmp.peer_finish_md, count);
742                 }
743         return ret;
744         }
745
746
747 int SSL_get_verify_mode(const SSL *s)
748         {
749         return(s->verify_mode);
750         }
751
752 int SSL_get_verify_depth(const SSL *s)
753         {
754         return X509_VERIFY_PARAM_get_depth(s->param);
755         }
756
757 int (*SSL_get_verify_callback(const SSL *s))(int,X509_STORE_CTX *)
758         {
759         return(s->verify_callback);
760         }
761
762 int SSL_CTX_get_verify_mode(const SSL_CTX *ctx)
763         {
764         return(ctx->verify_mode);
765         }
766
767 int SSL_CTX_get_verify_depth(const SSL_CTX *ctx)
768         {
769         return X509_VERIFY_PARAM_get_depth(ctx->param);
770         }
771
772 int (*SSL_CTX_get_verify_callback(const SSL_CTX *ctx))(int,X509_STORE_CTX *)
773         {
774         return(ctx->default_verify_callback);
775         }
776
777 void SSL_set_verify(SSL *s,int mode,
778                     int (*callback)(int ok,X509_STORE_CTX *ctx))
779         {
780         s->verify_mode=mode;
781         if (callback != NULL)
782                 s->verify_callback=callback;
783         }
784
785 void SSL_set_verify_depth(SSL *s,int depth)
786         {
787         X509_VERIFY_PARAM_set_depth(s->param, depth);
788         }
789
790 void SSL_set_read_ahead(SSL *s,int yes)
791         {
792         s->read_ahead=yes;
793         }
794
795 int SSL_get_read_ahead(const SSL *s)
796         {
797         return(s->read_ahead);
798         }
799
800 int SSL_pending(const SSL *s)
801         {
802         /* SSL_pending cannot work properly if read-ahead is enabled
803          * (SSL_[CTX_]ctrl(..., SSL_CTRL_SET_READ_AHEAD, 1, NULL)),
804          * and it is impossible to fix since SSL_pending cannot report
805          * errors that may be observed while scanning the new data.
806          * (Note that SSL_pending() is often used as a boolean value,
807          * so we'd better not return -1.)
808          */
809         return(s->method->ssl_pending(s));
810         }
811
812 X509 *SSL_get_peer_certificate(const SSL *s)
813         {
814         X509 *r;
815         
816         if ((s == NULL) || (s->session == NULL))
817                 r=NULL;
818         else
819                 r=s->session->peer;
820
821         if (r == NULL) return(r);
822
823         CRYPTO_add(&r->references,1,CRYPTO_LOCK_X509);
824
825         return(r);
826         }
827
828 STACK_OF(X509) *SSL_get_peer_cert_chain(const SSL *s)
829         {
830         STACK_OF(X509) *r;
831         
832         if ((s == NULL) || (s->session == NULL) || (s->session->sess_cert == NULL))
833                 r=NULL;
834         else
835                 r=s->session->sess_cert->cert_chain;
836
837         /* If we are a client, cert_chain includes the peer's own
838          * certificate; if we are a server, it does not. */
839         
840         return(r);
841         }
842
843 /* Now in theory, since the calling process own 't' it should be safe to
844  * modify.  We need to be able to read f without being hassled */
845 void SSL_copy_session_id(SSL *t,const SSL *f)
846         {
847         CERT *tmp;
848
849         /* Do we need to to SSL locking? */
850         SSL_set_session(t,SSL_get_session(f));
851
852         /* what if we are setup as SSLv2 but want to talk SSLv3 or
853          * vice-versa */
854         if (t->method != f->method)
855                 {
856                 t->method->ssl_free(t); /* cleanup current */
857                 t->method=f->method;    /* change method */
858                 t->method->ssl_new(t);  /* setup new */
859                 }
860
861         tmp=t->cert;
862         if (f->cert != NULL)
863                 {
864                 CRYPTO_add(&f->cert->references,1,CRYPTO_LOCK_SSL_CERT);
865                 t->cert=f->cert;
866                 }
867         else
868                 t->cert=NULL;
869         if (tmp != NULL) ssl_cert_free(tmp);
870         SSL_set_session_id_context(t,f->sid_ctx,f->sid_ctx_length);
871         }
872
873 /* Fix this so it checks all the valid key/cert options */
874 int SSL_CTX_check_private_key(const SSL_CTX *ctx)
875         {
876         if (    (ctx == NULL) ||
877                 (ctx->cert == NULL) ||
878                 (ctx->cert->key->x509 == NULL))
879                 {
880                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
881                 return(0);
882                 }
883         if      (ctx->cert->key->privatekey == NULL)
884                 {
885                 SSLerr(SSL_F_SSL_CTX_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
886                 return(0);
887                 }
888         return(X509_check_private_key(ctx->cert->key->x509, ctx->cert->key->privatekey));
889         }
890
891 /* Fix this function so that it takes an optional type parameter */
892 int SSL_check_private_key(const SSL *ssl)
893         {
894         if (ssl == NULL)
895                 {
896                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,ERR_R_PASSED_NULL_PARAMETER);
897                 return(0);
898                 }
899         if (ssl->cert == NULL)
900                 {
901                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
902                 return 0;
903                 }
904         if (ssl->cert->key->x509 == NULL)
905                 {
906                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
907                 return(0);
908                 }
909         if (ssl->cert->key->privatekey == NULL)
910                 {
911                 SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_PRIVATE_KEY_ASSIGNED);
912                 return(0);
913                 }
914         return(X509_check_private_key(ssl->cert->key->x509,
915                 ssl->cert->key->privatekey));
916         }
917
918 int SSL_accept(SSL *s)
919         {
920         if (s->handshake_func == 0)
921                 /* Not properly initialized yet */
922                 SSL_set_accept_state(s);
923
924         return(s->method->ssl_accept(s));
925         }
926
927 int SSL_connect(SSL *s)
928         {
929         if (s->handshake_func == 0)
930                 /* Not properly initialized yet */
931                 SSL_set_connect_state(s);
932
933         return(s->method->ssl_connect(s));
934         }
935
936 long SSL_get_default_timeout(const SSL *s)
937         {
938         return(s->method->get_timeout());
939         }
940
941 int SSL_read(SSL *s,void *buf,int num)
942         {
943         if (s->handshake_func == 0)
944                 {
945                 SSLerr(SSL_F_SSL_READ, SSL_R_UNINITIALIZED);
946                 return -1;
947                 }
948
949         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
950                 {
951                 s->rwstate=SSL_NOTHING;
952                 return(0);
953                 }
954         return(s->method->ssl_read(s,buf,num));
955         }
956
957 int SSL_peek(SSL *s,void *buf,int num)
958         {
959         if (s->handshake_func == 0)
960                 {
961                 SSLerr(SSL_F_SSL_PEEK, SSL_R_UNINITIALIZED);
962                 return -1;
963                 }
964
965         if (s->shutdown & SSL_RECEIVED_SHUTDOWN)
966                 {
967                 return(0);
968                 }
969         return(s->method->ssl_peek(s,buf,num));
970         }
971
972 int SSL_write(SSL *s,const void *buf,int num)
973         {
974         if (s->handshake_func == 0)
975                 {
976                 SSLerr(SSL_F_SSL_WRITE, SSL_R_UNINITIALIZED);
977                 return -1;
978                 }
979
980         if (s->shutdown & SSL_SENT_SHUTDOWN)
981                 {
982                 s->rwstate=SSL_NOTHING;
983                 SSLerr(SSL_F_SSL_WRITE,SSL_R_PROTOCOL_IS_SHUTDOWN);
984                 return(-1);
985                 }
986         return(s->method->ssl_write(s,buf,num));
987         }
988
989 int SSL_shutdown(SSL *s)
990         {
991         /* Note that this function behaves differently from what one might
992          * expect.  Return values are 0 for no success (yet),
993          * 1 for success; but calling it once is usually not enough,
994          * even if blocking I/O is used (see ssl3_shutdown).
995          */
996
997         if (s->handshake_func == 0)
998                 {
999                 SSLerr(SSL_F_SSL_SHUTDOWN, SSL_R_UNINITIALIZED);
1000                 return -1;
1001                 }
1002
1003         if ((s != NULL) && !SSL_in_init(s))
1004                 return(s->method->ssl_shutdown(s));
1005         else
1006                 return(1);
1007         }
1008
1009 int SSL_renegotiate(SSL *s)
1010         {
1011         if (s->new_session == 0)
1012                 {
1013                 s->new_session=1;
1014                 }
1015         return(s->method->ssl_renegotiate(s));
1016         }
1017
1018 int SSL_renegotiate_pending(SSL *s)
1019         {
1020         /* becomes true when negotiation is requested;
1021          * false again once a handshake has finished */
1022         return (s->new_session != 0);
1023         }
1024
1025 long SSL_ctrl(SSL *s,int cmd,long larg,void *parg)
1026         {
1027         long l;
1028
1029         switch (cmd)
1030                 {
1031         case SSL_CTRL_GET_READ_AHEAD:
1032                 return(s->read_ahead);
1033         case SSL_CTRL_SET_READ_AHEAD:
1034                 l=s->read_ahead;
1035                 s->read_ahead=larg;
1036                 return(l);
1037
1038         case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1039                 s->msg_callback_arg = parg;
1040                 return 1;
1041
1042         case SSL_CTRL_OPTIONS:
1043                 return(s->options|=larg);
1044         case SSL_CTRL_CLEAR_OPTIONS:
1045                 return(s->options&=~larg);
1046         case SSL_CTRL_MODE:
1047                 return(s->mode|=larg);
1048         case SSL_CTRL_CLEAR_MODE:
1049                 return(s->mode &=~larg);
1050         case SSL_CTRL_GET_MAX_CERT_LIST:
1051                 return(s->max_cert_list);
1052         case SSL_CTRL_SET_MAX_CERT_LIST:
1053                 l=s->max_cert_list;
1054                 s->max_cert_list=larg;
1055                 return(l);
1056         case SSL_CTRL_SET_MTU:
1057                 if (SSL_version(s) == DTLS1_VERSION ||
1058                     SSL_version(s) == DTLS1_BAD_VER)
1059                         {
1060                         s->d1->mtu = larg;
1061                         return larg;
1062                         }
1063                 return 0;
1064         case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1065                 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1066                         return 0;
1067                 s->max_send_fragment = larg;
1068                 return 1;
1069         case SSL_CTRL_GET_RI_SUPPORT:
1070                 if (s->s3)
1071                         return s->s3->send_connection_binding;
1072                 else return 0;
1073         default:
1074                 return(s->method->ssl_ctrl(s,cmd,larg,parg));
1075                 }
1076         }
1077
1078 long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)(void))
1079         {
1080         switch(cmd)
1081                 {
1082         case SSL_CTRL_SET_MSG_CALLBACK:
1083                 s->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1084                 return 1;
1085                 
1086         default:
1087                 return(s->method->ssl_callback_ctrl(s,cmd,fp));
1088                 }
1089         }
1090
1091 LHASH_OF(SSL_SESSION) *SSL_CTX_sessions(SSL_CTX *ctx)
1092         {
1093         return ctx->sessions;
1094         }
1095
1096 long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,void *parg)
1097         {
1098         long l;
1099
1100         switch (cmd)
1101                 {
1102         case SSL_CTRL_GET_READ_AHEAD:
1103                 return(ctx->read_ahead);
1104         case SSL_CTRL_SET_READ_AHEAD:
1105                 l=ctx->read_ahead;
1106                 ctx->read_ahead=larg;
1107                 return(l);
1108                 
1109         case SSL_CTRL_SET_MSG_CALLBACK_ARG:
1110                 ctx->msg_callback_arg = parg;
1111                 return 1;
1112
1113         case SSL_CTRL_GET_MAX_CERT_LIST:
1114                 return(ctx->max_cert_list);
1115         case SSL_CTRL_SET_MAX_CERT_LIST:
1116                 l=ctx->max_cert_list;
1117                 ctx->max_cert_list=larg;
1118                 return(l);
1119
1120         case SSL_CTRL_SET_SESS_CACHE_SIZE:
1121                 l=ctx->session_cache_size;
1122                 ctx->session_cache_size=larg;
1123                 return(l);
1124         case SSL_CTRL_GET_SESS_CACHE_SIZE:
1125                 return(ctx->session_cache_size);
1126         case SSL_CTRL_SET_SESS_CACHE_MODE:
1127                 l=ctx->session_cache_mode;
1128                 ctx->session_cache_mode=larg;
1129                 return(l);
1130         case SSL_CTRL_GET_SESS_CACHE_MODE:
1131                 return(ctx->session_cache_mode);
1132
1133         case SSL_CTRL_SESS_NUMBER:
1134                 return(lh_SSL_SESSION_num_items(ctx->sessions));
1135         case SSL_CTRL_SESS_CONNECT:
1136                 return(ctx->stats.sess_connect);
1137         case SSL_CTRL_SESS_CONNECT_GOOD:
1138                 return(ctx->stats.sess_connect_good);
1139         case SSL_CTRL_SESS_CONNECT_RENEGOTIATE:
1140                 return(ctx->stats.sess_connect_renegotiate);
1141         case SSL_CTRL_SESS_ACCEPT:
1142                 return(ctx->stats.sess_accept);
1143         case SSL_CTRL_SESS_ACCEPT_GOOD:
1144                 return(ctx->stats.sess_accept_good);
1145         case SSL_CTRL_SESS_ACCEPT_RENEGOTIATE:
1146                 return(ctx->stats.sess_accept_renegotiate);
1147         case SSL_CTRL_SESS_HIT:
1148                 return(ctx->stats.sess_hit);
1149         case SSL_CTRL_SESS_CB_HIT:
1150                 return(ctx->stats.sess_cb_hit);
1151         case SSL_CTRL_SESS_MISSES:
1152                 return(ctx->stats.sess_miss);
1153         case SSL_CTRL_SESS_TIMEOUTS:
1154                 return(ctx->stats.sess_timeout);
1155         case SSL_CTRL_SESS_CACHE_FULL:
1156                 return(ctx->stats.sess_cache_full);
1157         case SSL_CTRL_OPTIONS:
1158                 return(ctx->options|=larg);
1159         case SSL_CTRL_CLEAR_OPTIONS:
1160                 return(ctx->options&=~larg);
1161         case SSL_CTRL_MODE:
1162                 return(ctx->mode|=larg);
1163         case SSL_CTRL_CLEAR_MODE:
1164                 return(ctx->mode&=~larg);
1165         case SSL_CTRL_SET_MAX_SEND_FRAGMENT:
1166                 if (larg < 512 || larg > SSL3_RT_MAX_PLAIN_LENGTH)
1167                         return 0;
1168                 ctx->max_send_fragment = larg;
1169                 return 1;
1170         default:
1171                 return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
1172                 }
1173         }
1174
1175 long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)(void))
1176         {
1177         switch(cmd)
1178                 {
1179         case SSL_CTRL_SET_MSG_CALLBACK:
1180                 ctx->msg_callback = (void (*)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))(fp);
1181                 return 1;
1182
1183         default:
1184                 return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
1185                 }
1186         }
1187
1188 int ssl_cipher_id_cmp(const SSL_CIPHER *a, const SSL_CIPHER *b)
1189         {
1190         long l;
1191
1192         l=a->id-b->id;
1193         if (l == 0L)
1194                 return(0);
1195         else
1196                 return((l > 0)?1:-1);
1197         }
1198
1199 int ssl_cipher_ptr_id_cmp(const SSL_CIPHER * const *ap,
1200                         const SSL_CIPHER * const *bp)
1201         {
1202         long l;
1203
1204         l=(*ap)->id-(*bp)->id;
1205         if (l == 0L)
1206                 return(0);
1207         else
1208                 return((l > 0)?1:-1);
1209         }
1210
1211 /** return a STACK of the ciphers available for the SSL and in order of
1212  * preference */
1213 STACK_OF(SSL_CIPHER) *SSL_get_ciphers(const SSL *s)
1214         {
1215         if (s != NULL)
1216                 {
1217                 if (s->cipher_list != NULL)
1218                         {
1219                         return(s->cipher_list);
1220                         }
1221                 else if ((s->ctx != NULL) &&
1222                         (s->ctx->cipher_list != NULL))
1223                         {
1224                         return(s->ctx->cipher_list);
1225                         }
1226                 }
1227         return(NULL);
1228         }
1229
1230 /** return a STACK of the ciphers available for the SSL and in order of
1231  * algorithm id */
1232 STACK_OF(SSL_CIPHER) *ssl_get_ciphers_by_id(SSL *s)
1233         {
1234         if (s != NULL)
1235                 {
1236                 if (s->cipher_list_by_id != NULL)
1237                         {
1238                         return(s->cipher_list_by_id);
1239                         }
1240                 else if ((s->ctx != NULL) &&
1241                         (s->ctx->cipher_list_by_id != NULL))
1242                         {
1243                         return(s->ctx->cipher_list_by_id);
1244                         }
1245                 }
1246         return(NULL);
1247         }
1248
1249 /** The old interface to get the same thing as SSL_get_ciphers() */
1250 const char *SSL_get_cipher_list(const SSL *s,int n)
1251         {
1252         SSL_CIPHER *c;
1253         STACK_OF(SSL_CIPHER) *sk;
1254
1255         if (s == NULL) return(NULL);
1256         sk=SSL_get_ciphers(s);
1257         if ((sk == NULL) || (sk_SSL_CIPHER_num(sk) <= n))
1258                 return(NULL);
1259         c=sk_SSL_CIPHER_value(sk,n);
1260         if (c == NULL) return(NULL);
1261         return(c->name);
1262         }
1263
1264 /** specify the ciphers to be used by default by the SSL_CTX */
1265 int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
1266         {
1267         STACK_OF(SSL_CIPHER) *sk;
1268         
1269         sk=ssl_create_cipher_list(ctx->method,&ctx->cipher_list,
1270                 &ctx->cipher_list_by_id,str);
1271         /* ssl_create_cipher_list may return an empty stack if it
1272          * was unable to find a cipher matching the given rule string
1273          * (for example if the rule string specifies a cipher which
1274          * has been disabled). This is not an error as far as
1275          * ssl_create_cipher_list is concerned, and hence
1276          * ctx->cipher_list and ctx->cipher_list_by_id has been
1277          * updated. */
1278         if (sk == NULL)
1279                 return 0;
1280         else if (sk_SSL_CIPHER_num(sk) == 0)
1281                 {
1282                 SSLerr(SSL_F_SSL_CTX_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1283                 return 0;
1284                 }
1285         return 1;
1286         }
1287
1288 /** specify the ciphers to be used by the SSL */
1289 int SSL_set_cipher_list(SSL *s,const char *str)
1290         {
1291         STACK_OF(SSL_CIPHER) *sk;
1292         
1293         sk=ssl_create_cipher_list(s->ctx->method,&s->cipher_list,
1294                 &s->cipher_list_by_id,str);
1295         /* see comment in SSL_CTX_set_cipher_list */
1296         if (sk == NULL)
1297                 return 0;
1298         else if (sk_SSL_CIPHER_num(sk) == 0)
1299                 {
1300                 SSLerr(SSL_F_SSL_SET_CIPHER_LIST, SSL_R_NO_CIPHER_MATCH);
1301                 return 0;
1302                 }
1303         return 1;
1304         }
1305
1306 /* works well for SSLv2, not so good for SSLv3 */
1307 char *SSL_get_shared_ciphers(const SSL *s,char *buf,int len)
1308         {
1309         char *p;
1310         STACK_OF(SSL_CIPHER) *sk;
1311         SSL_CIPHER *c;
1312         int i;
1313
1314         if ((s->session == NULL) || (s->session->ciphers == NULL) ||
1315                 (len < 2))
1316                 return(NULL);
1317
1318         p=buf;
1319         sk=s->session->ciphers;
1320         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1321                 {
1322                 int n;
1323
1324                 c=sk_SSL_CIPHER_value(sk,i);
1325                 n=strlen(c->name);
1326                 if (n+1 > len)
1327                         {
1328                         if (p != buf)
1329                                 --p;
1330                         *p='\0';
1331                         return buf;
1332                         }
1333                 strcpy(p,c->name);
1334                 p+=n;
1335                 *(p++)=':';
1336                 len-=n+1;
1337                 }
1338         p[-1]='\0';
1339         return(buf);
1340         }
1341
1342 int ssl_cipher_list_to_bytes(SSL *s,STACK_OF(SSL_CIPHER) *sk,unsigned char *p,
1343                              int (*put_cb)(const SSL_CIPHER *, unsigned char *))
1344         {
1345         int i,j=0;
1346         SSL_CIPHER *c;
1347         unsigned char *q;
1348 #ifndef OPENSSL_NO_KRB5
1349         int nokrb5 = !kssl_tgt_is_available(s->kssl_ctx);
1350 #endif /* OPENSSL_NO_KRB5 */
1351
1352         if (sk == NULL) return(0);
1353         q=p;
1354
1355         for (i=0; i<sk_SSL_CIPHER_num(sk); i++)
1356                 {
1357                 c=sk_SSL_CIPHER_value(sk,i);
1358 #ifndef OPENSSL_NO_KRB5
1359                 if (((c->algorithm_mkey & SSL_kKRB5) || (c->algorithm_auth & SSL_aKRB5)) &&
1360                     nokrb5)
1361                     continue;
1362 #endif /* OPENSSL_NO_KRB5 */
1363 #ifndef OPENSSL_NO_PSK
1364                 /* with PSK there must be client callback set */
1365                 if (((c->algorithm_mkey & SSL_kPSK) || (c->algorithm_auth & SSL_aPSK)) &&
1366                     s->psk_client_callback == NULL)
1367                         continue;
1368 #endif /* OPENSSL_NO_PSK */
1369                 j = put_cb ? put_cb(c,p) : ssl_put_cipher_by_char(s,c,p);
1370                 p+=j;
1371                 }
1372         /* If p == q, no ciphers and caller indicates an error, otherwise
1373          * add SCSV if not renegotiating
1374          */
1375         if (p != q && !s->new_session)
1376                 {
1377                 static SSL_CIPHER scsv =
1378                         {
1379                         0, NULL, SSL3_CK_SCSV, 0, 0, 0, 0, 0, 0, 0, 0, 0
1380                         };
1381                 j = put_cb ? put_cb(&scsv,p) : ssl_put_cipher_by_char(s,&scsv,p);
1382                 p+=j;
1383 #ifdef OPENSSL_RI_DEBUG
1384                 fprintf(stderr, "SCSV sent by client\n");
1385 #endif
1386                 }
1387
1388         return(p-q);
1389         }
1390
1391 STACK_OF(SSL_CIPHER) *ssl_bytes_to_cipher_list(SSL *s,unsigned char *p,int num,
1392                                                STACK_OF(SSL_CIPHER) **skp)
1393         {
1394         const SSL_CIPHER *c;
1395         STACK_OF(SSL_CIPHER) *sk;
1396         int i,n;
1397         if (s->s3)
1398                 s->s3->send_connection_binding = 0;
1399
1400         n=ssl_put_cipher_by_char(s,NULL,NULL);
1401         if ((num%n) != 0)
1402                 {
1403                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,SSL_R_ERROR_IN_RECEIVED_CIPHER_LIST);
1404                 return(NULL);
1405                 }
1406         if ((skp == NULL) || (*skp == NULL))
1407                 sk=sk_SSL_CIPHER_new_null(); /* change perhaps later */
1408         else
1409                 {
1410                 sk= *skp;
1411                 sk_SSL_CIPHER_zero(sk);
1412                 }
1413
1414         for (i=0; i<num; i+=n)
1415                 {
1416                 /* Check for SCSV */
1417                 if (s->s3 && (n != 3 || !p[0]) &&
1418                         (p[n-2] == ((SSL3_CK_SCSV >> 8) & 0xff)) &&
1419                         (p[n-1] == (SSL3_CK_SCSV & 0xff)))
1420                         {
1421                         s->s3->send_connection_binding = 1;
1422                         p += n;
1423 #ifdef OPENSSL_RI_DEBUG
1424                         fprintf(stderr, "SCSV received by server\n");
1425 #endif
1426                         continue;
1427                         }
1428
1429                 c=ssl_get_cipher_by_char(s,p);
1430                 p+=n;
1431                 if (c != NULL)
1432                         {
1433                         if (!sk_SSL_CIPHER_push(sk,c))
1434                                 {
1435                                 SSLerr(SSL_F_SSL_BYTES_TO_CIPHER_LIST,ERR_R_MALLOC_FAILURE);
1436                                 goto err;
1437                                 }
1438                         }
1439                 }
1440
1441         if (skp != NULL)
1442                 *skp=sk;
1443         return(sk);
1444 err:
1445         if ((skp == NULL) || (*skp == NULL))
1446                 sk_SSL_CIPHER_free(sk);
1447         return(NULL);
1448         }
1449
1450
1451 #ifndef OPENSSL_NO_TLSEXT
1452 /** return a servername extension value if provided in Client Hello, or NULL.
1453  * So far, only host_name types are defined (RFC 3546).
1454  */
1455
1456 const char *SSL_get_servername(const SSL *s, const int type)
1457         {
1458         if (type != TLSEXT_NAMETYPE_host_name)
1459                 return NULL;
1460
1461         return s->session && !s->tlsext_hostname ?
1462                 s->session->tlsext_hostname :
1463                 s->tlsext_hostname;
1464         }
1465
1466 int SSL_get_servername_type(const SSL *s)
1467         {
1468         if (s->session && (!s->tlsext_hostname ? s->session->tlsext_hostname : s->tlsext_hostname))
1469                 return TLSEXT_NAMETYPE_host_name;
1470         return -1;
1471         }
1472 #endif
1473
1474 static unsigned long ssl_session_hash(const SSL_SESSION *a)
1475         {
1476         unsigned long l;
1477
1478         l=(unsigned long)
1479                 ((unsigned int) a->session_id[0]     )|
1480                 ((unsigned int) a->session_id[1]<< 8L)|
1481                 ((unsigned long)a->session_id[2]<<16L)|
1482                 ((unsigned long)a->session_id[3]<<24L);
1483         return(l);
1484         }
1485
1486 /* NB: If this function (or indeed the hash function which uses a sort of
1487  * coarser function than this one) is changed, ensure
1488  * SSL_CTX_has_matching_session_id() is checked accordingly. It relies on being
1489  * able to construct an SSL_SESSION that will collide with any existing session
1490  * with a matching session ID. */
1491 static int ssl_session_cmp(const SSL_SESSION *a,const SSL_SESSION *b)
1492         {
1493         if (a->ssl_version != b->ssl_version)
1494                 return(1);
1495         if (a->session_id_length != b->session_id_length)
1496                 return(1);
1497         return(memcmp(a->session_id,b->session_id,a->session_id_length));
1498         }
1499
1500 /* These wrapper functions should remain rather than redeclaring
1501  * SSL_SESSION_hash and SSL_SESSION_cmp for void* types and casting each
1502  * variable. The reason is that the functions aren't static, they're exposed via
1503  * ssl.h. */
1504 static IMPLEMENT_LHASH_HASH_FN(ssl_session, SSL_SESSION)
1505 static IMPLEMENT_LHASH_COMP_FN(ssl_session, SSL_SESSION)
1506
1507 SSL_CTX *SSL_CTX_new(const SSL_METHOD *meth)
1508         {
1509         SSL_CTX *ret=NULL;
1510
1511         if (meth == NULL)
1512                 {
1513                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_NULL_SSL_METHOD_PASSED);
1514                 return(NULL);
1515                 }
1516
1517         if (SSL_get_ex_data_X509_STORE_CTX_idx() < 0)
1518                 {
1519                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_X509_VERIFICATION_SETUP_PROBLEMS);
1520                 goto err;
1521                 }
1522         ret=(SSL_CTX *)OPENSSL_malloc(sizeof(SSL_CTX));
1523         if (ret == NULL)
1524                 goto err;
1525
1526         memset(ret,0,sizeof(SSL_CTX));
1527
1528         ret->method=meth;
1529
1530         ret->cert_store=NULL;
1531         ret->session_cache_mode=SSL_SESS_CACHE_SERVER;
1532         ret->session_cache_size=SSL_SESSION_CACHE_MAX_SIZE_DEFAULT;
1533         ret->session_cache_head=NULL;
1534         ret->session_cache_tail=NULL;
1535
1536         /* We take the system default */
1537         ret->session_timeout=meth->get_timeout();
1538
1539         ret->new_session_cb=0;
1540         ret->remove_session_cb=0;
1541         ret->get_session_cb=0;
1542         ret->generate_session_id=0;
1543
1544         memset((char *)&ret->stats,0,sizeof(ret->stats));
1545
1546         ret->references=1;
1547         ret->quiet_shutdown=0;
1548
1549 /*      ret->cipher=NULL;*/
1550 /*      ret->s2->challenge=NULL;
1551         ret->master_key=NULL;
1552         ret->key_arg=NULL;
1553         ret->s2->conn_id=NULL; */
1554
1555         ret->info_callback=NULL;
1556
1557         ret->app_verify_callback=0;
1558         ret->app_verify_arg=NULL;
1559
1560         ret->max_cert_list=SSL_MAX_CERT_LIST_DEFAULT;
1561         ret->read_ahead=0;
1562         ret->msg_callback=0;
1563         ret->msg_callback_arg=NULL;
1564         ret->verify_mode=SSL_VERIFY_NONE;
1565 #if 0
1566         ret->verify_depth=-1; /* Don't impose a limit (but x509_lu.c does) */
1567 #endif
1568         ret->sid_ctx_length=0;
1569         ret->default_verify_callback=NULL;
1570         if ((ret->cert=ssl_cert_new()) == NULL)
1571                 goto err;
1572
1573         ret->default_passwd_callback=0;
1574         ret->default_passwd_callback_userdata=NULL;
1575         ret->client_cert_cb=0;
1576         ret->app_gen_cookie_cb=0;
1577         ret->app_verify_cookie_cb=0;
1578
1579         ret->sessions=lh_SSL_SESSION_new();
1580         if (ret->sessions == NULL) goto err;
1581         ret->cert_store=X509_STORE_new();
1582         if (ret->cert_store == NULL) goto err;
1583
1584         ssl_create_cipher_list(ret->method,
1585                 &ret->cipher_list,&ret->cipher_list_by_id,
1586                 meth->version == SSL2_VERSION ? "SSLv2" : SSL_DEFAULT_CIPHER_LIST);
1587         if (ret->cipher_list == NULL
1588             || sk_SSL_CIPHER_num(ret->cipher_list) <= 0)
1589                 {
1590                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_LIBRARY_HAS_NO_CIPHERS);
1591                 goto err2;
1592                 }
1593
1594         ret->param = X509_VERIFY_PARAM_new();
1595         if (!ret->param)
1596                 goto err;
1597
1598         if ((ret->rsa_md5=EVP_get_digestbyname("ssl2-md5")) == NULL)
1599                 {
1600                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL2_MD5_ROUTINES);
1601                 goto err2;
1602                 }
1603         if ((ret->md5=EVP_get_digestbyname("ssl3-md5")) == NULL)
1604                 {
1605                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_MD5_ROUTINES);
1606                 goto err2;
1607                 }
1608         if ((ret->sha1=EVP_get_digestbyname("ssl3-sha1")) == NULL)
1609                 {
1610                 SSLerr(SSL_F_SSL_CTX_NEW,SSL_R_UNABLE_TO_LOAD_SSL3_SHA1_ROUTINES);
1611                 goto err2;
1612                 }
1613
1614         if ((ret->client_CA=sk_X509_NAME_new_null()) == NULL)
1615                 goto err;
1616
1617         CRYPTO_new_ex_data(CRYPTO_EX_INDEX_SSL_CTX, ret, &ret->ex_data);
1618
1619         ret->extra_certs=NULL;
1620         ret->comp_methods=SSL_COMP_get_compression_methods();
1621
1622         ret->max_send_fragment = SSL3_RT_MAX_PLAIN_LENGTH;
1623
1624 #ifndef OPENSSL_NO_TLSEXT
1625         ret->tlsext_servername_callback = 0;
1626         ret->tlsext_servername_arg = NULL;
1627         /* Setup RFC4507 ticket keys */
1628         if ((RAND_pseudo_bytes(ret->tlsext_tick_key_name, 16) <= 0)
1629                 || (RAND_bytes(ret->tlsext_tick_hmac_key, 16) <= 0)
1630                 || (RAND_bytes(ret->tlsext_tick_aes_key, 16) <= 0))
1631                 ret->options |= SSL_OP_NO_TICKET;
1632
1633         ret->tlsext_status_cb = 0;
1634         ret->tlsext_status_arg = NULL;
1635
1636 #endif
1637 #ifndef OPENSSL_NO_PSK
1638         ret->psk_identity_hint=NULL;
1639         ret->psk_client_callback=NULL;
1640         ret->psk_server_callback=NULL;
1641 #endif
1642 #ifndef OPENSSL_NO_BUF_FREELISTS
1643         ret->freelist_max_len = SSL_MAX_BUF_FREELIST_LEN_DEFAULT;
1644         ret->rbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
1645         if (!ret->rbuf_freelist)
1646                 goto err;
1647         ret->rbuf_freelist->chunklen = 0;
1648         ret->rbuf_freelist->len = 0;
1649         ret->rbuf_freelist->head = NULL;
1650         ret->wbuf_freelist = OPENSSL_malloc(sizeof(SSL3_BUF_FREELIST));
1651         if (!ret->wbuf_freelist)
1652                 {
1653                 OPENSSL_free(ret->rbuf_freelist);
1654                 goto err;
1655                 }
1656         ret->wbuf_freelist->chunklen = 0;
1657         ret->wbuf_freelist->len = 0;
1658         ret->wbuf_freelist->head = NULL;
1659 #endif
1660 #ifndef OPENSSL_NO_ENGINE
1661         ret->client_cert_engine = NULL;
1662 #ifdef OPENSSL_SSL_CLIENT_ENGINE_AUTO
1663 #define eng_strx(x)     #x
1664 #define eng_str(x)      eng_strx(x)
1665         /* Use specific client engine automatically... ignore errors */
1666         {
1667         ENGINE *eng;
1668         eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1669         if (!eng)
1670                 {
1671                 ERR_clear_error();
1672                 ENGINE_load_builtin_engines();
1673                 eng = ENGINE_by_id(eng_str(OPENSSL_SSL_CLIENT_ENGINE_AUTO));
1674                 }
1675         if (!eng || !SSL_CTX_set_client_cert_engine(ret, eng))
1676                 ERR_clear_error();
1677         }
1678 #endif
1679 #endif
1680         /* Default is to connect to non-RI servers. When RI is more widely
1681          * deployed might change this.
1682          */
1683         ret->options = SSL_OP_LEGACY_SERVER_CONNECT;
1684
1685         return(ret);
1686 err:
1687         SSLerr(SSL_F_SSL_CTX_NEW,ERR_R_MALLOC_FAILURE);
1688 err2:
1689         if (ret != NULL) SSL_CTX_free(ret);
1690         return(NULL);
1691         }
1692
1693 #if 0
1694 static void SSL_COMP_free(SSL_COMP *comp)
1695     { OPENSSL_free(comp); }
1696 #endif
1697
1698 #ifndef OPENSSL_NO_BUF_FREELISTS
1699 static void
1700 ssl_buf_freelist_free(SSL3_BUF_FREELIST *list)
1701         {
1702         SSL3_BUF_FREELIST_ENTRY *ent, *next;
1703         for (ent = list->head; ent; ent = next)
1704                 {
1705                 next = ent->next;
1706                 OPENSSL_free(ent);
1707                 }
1708         OPENSSL_free(list);
1709         }
1710 #endif
1711
1712 void SSL_CTX_free(SSL_CTX *a)
1713         {
1714         int i;
1715
1716         if (a == NULL) return;
1717
1718         i=CRYPTO_add(&a->references,-1,CRYPTO_LOCK_SSL_CTX);
1719 #ifdef REF_PRINT
1720         REF_PRINT("SSL_CTX",a);
1721 #endif
1722         if (i > 0) return;
1723 #ifdef REF_CHECK
1724         if (i < 0)
1725                 {
1726                 fprintf(stderr,"SSL_CTX_free, bad reference count\n");
1727                 abort(); /* ok */
1728                 }
1729 #endif
1730
1731         if (a->param)
1732                 X509_VERIFY_PARAM_free(a->param);
1733
1734         /*
1735          * Free internal session cache. However: the remove_cb() may reference
1736          * the ex_data of SSL_CTX, thus the ex_data store can only be removed
1737          * after the sessions were flushed.
1738          * As the ex_data handling routines might also touch the session cache,
1739          * the most secure solution seems to be: empty (flush) the cache, then
1740          * free ex_data, then finally free the cache.
1741          * (See ticket [openssl.org #212].)
1742          */
1743         if (a->sessions != NULL)
1744                 SSL_CTX_flush_sessions(a,0);
1745
1746         CRYPTO_free_ex_data(CRYPTO_EX_INDEX_SSL_CTX, a, &a->ex_data);
1747
1748         if (a->sessions != NULL)
1749                 lh_SSL_SESSION_free(a->sessions);
1750
1751         if (a->cert_store != NULL)
1752                 X509_STORE_free(a->cert_store);
1753         if (a->cipher_list != NULL)
1754                 sk_SSL_CIPHER_free(a->cipher_list);
1755         if (a->cipher_list_by_id != NULL)
1756                 sk_SSL_CIPHER_free(a->cipher_list_by_id);
1757         if (a->cert != NULL)
1758                 ssl_cert_free(a->cert);
1759         if (a->client_CA != NULL)
1760                 sk_X509_NAME_pop_free(a->client_CA,X509_NAME_free);
1761         if (a->extra_certs != NULL)
1762                 sk_X509_pop_free(a->extra_certs,X509_free);
1763 #if 0 /* This should never be done, since it removes a global database */
1764         if (a->comp_methods != NULL)
1765                 sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
1766 #else
1767         a->comp_methods = NULL;
1768 #endif
1769
1770 #ifndef OPENSSL_NO_PSK
1771         if (a->psk_identity_hint)
1772                 OPENSSL_free(a->psk_identity_hint);
1773 #endif
1774 #ifndef OPENSSL_NO_ENGINE
1775         if (a->client_cert_engine)
1776                 ENGINE_finish(a->client_cert_engine);
1777 #endif
1778
1779 #ifndef OPENSSL_NO_BUF_FREELISTS
1780         if (a->wbuf_freelist)
1781                 ssl_buf_freelist_free(a->wbuf_freelist);
1782         if (a->rbuf_freelist)
1783                 ssl_buf_freelist_free(a->rbuf_freelist);
1784 #endif
1785
1786         OPENSSL_free(a);
1787         }
1788
1789 void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
1790         {
1791         ctx->default_passwd_callback=cb;
1792         }
1793
1794 void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
1795         {
1796         ctx->default_passwd_callback_userdata=u;
1797         }
1798
1799 void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx, int (*cb)(X509_STORE_CTX *,void *), void *arg)
1800         {
1801         ctx->app_verify_callback=cb;
1802         ctx->app_verify_arg=arg;
1803         }
1804
1805 void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
1806         {
1807         ctx->verify_mode=mode;
1808         ctx->default_verify_callback=cb;
1809         }
1810
1811 void SSL_CTX_set_verify_depth(SSL_CTX *ctx,int depth)
1812         {
1813         X509_VERIFY_PARAM_set_depth(ctx->param, depth);
1814         }
1815
1816 void ssl_set_cert_masks(CERT *c, const SSL_CIPHER *cipher)
1817         {
1818         CERT_PKEY *cpk;
1819         int rsa_enc,rsa_tmp,rsa_sign,dh_tmp,dh_rsa,dh_dsa,dsa_sign;
1820         int rsa_enc_export,dh_rsa_export,dh_dsa_export;
1821         int rsa_tmp_export,dh_tmp_export,kl;
1822         unsigned long mask_k,mask_a,emask_k,emask_a;
1823         int have_ecc_cert, ecdh_ok, ecdsa_ok, ecc_pkey_size;
1824 #ifndef OPENSSL_NO_ECDH
1825         int have_ecdh_tmp;
1826 #endif
1827         X509 *x = NULL;
1828         EVP_PKEY *ecc_pkey = NULL;
1829         int signature_nid = 0;
1830
1831         if (c == NULL) return;
1832
1833         kl=SSL_C_EXPORT_PKEYLENGTH(cipher);
1834
1835 #ifndef OPENSSL_NO_RSA
1836         rsa_tmp=(c->rsa_tmp != NULL || c->rsa_tmp_cb != NULL);
1837         rsa_tmp_export=(c->rsa_tmp_cb != NULL ||
1838                 (rsa_tmp && RSA_size(c->rsa_tmp)*8 <= kl));
1839 #else
1840         rsa_tmp=rsa_tmp_export=0;
1841 #endif
1842 #ifndef OPENSSL_NO_DH
1843         dh_tmp=(c->dh_tmp != NULL || c->dh_tmp_cb != NULL);
1844         dh_tmp_export=(c->dh_tmp_cb != NULL ||
1845                 (dh_tmp && DH_size(c->dh_tmp)*8 <= kl));
1846 #else
1847         dh_tmp=dh_tmp_export=0;
1848 #endif
1849
1850 #ifndef OPENSSL_NO_ECDH
1851         have_ecdh_tmp=(c->ecdh_tmp != NULL || c->ecdh_tmp_cb != NULL);
1852 #endif
1853         cpk= &(c->pkeys[SSL_PKEY_RSA_ENC]);
1854         rsa_enc= (cpk->x509 != NULL && cpk->privatekey != NULL);
1855         rsa_enc_export=(rsa_enc && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1856         cpk= &(c->pkeys[SSL_PKEY_RSA_SIGN]);
1857         rsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1858         cpk= &(c->pkeys[SSL_PKEY_DSA_SIGN]);
1859         dsa_sign=(cpk->x509 != NULL && cpk->privatekey != NULL);
1860         cpk= &(c->pkeys[SSL_PKEY_DH_RSA]);
1861         dh_rsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
1862         dh_rsa_export=(dh_rsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1863         cpk= &(c->pkeys[SSL_PKEY_DH_DSA]);
1864 /* FIX THIS EAY EAY EAY */
1865         dh_dsa=  (cpk->x509 != NULL && cpk->privatekey != NULL);
1866         dh_dsa_export=(dh_dsa && EVP_PKEY_size(cpk->privatekey)*8 <= kl);
1867         cpk= &(c->pkeys[SSL_PKEY_ECC]);
1868         have_ecc_cert= (cpk->x509 != NULL && cpk->privatekey != NULL);
1869         mask_k=0;
1870         mask_a=0;
1871         emask_k=0;
1872         emask_a=0;
1873
1874         
1875
1876 #ifdef CIPHER_DEBUG
1877         printf("rt=%d rte=%d dht=%d ecdht=%d re=%d ree=%d rs=%d ds=%d dhr=%d dhd=%d\n",
1878                 rsa_tmp,rsa_tmp_export,dh_tmp,have_ecdh_tmp,
1879                 rsa_enc,rsa_enc_export,rsa_sign,dsa_sign,dh_rsa,dh_dsa);
1880 #endif
1881         
1882         cpk = &(c->pkeys[SSL_PKEY_GOST01]);
1883         if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
1884                 mask_k |= SSL_kGOST;
1885                 mask_a |= SSL_aGOST01;
1886         }
1887         cpk = &(c->pkeys[SSL_PKEY_GOST94]);
1888         if (cpk->x509 != NULL && cpk->privatekey !=NULL) {
1889                 mask_k |= SSL_kGOST;
1890                 mask_a |= SSL_aGOST94;
1891         }
1892
1893         if (rsa_enc || (rsa_tmp && rsa_sign))
1894                 mask_k|=SSL_kRSA;
1895         if (rsa_enc_export || (rsa_tmp_export && (rsa_sign || rsa_enc)))
1896                 emask_k|=SSL_kRSA;
1897
1898 #if 0
1899         /* The match needs to be both kEDH and aRSA or aDSA, so don't worry */
1900         if (    (dh_tmp || dh_rsa || dh_dsa) &&
1901                 (rsa_enc || rsa_sign || dsa_sign))
1902                 mask_k|=SSL_kEDH;
1903         if ((dh_tmp_export || dh_rsa_export || dh_dsa_export) &&
1904                 (rsa_enc || rsa_sign || dsa_sign))
1905                 emask_k|=SSL_kEDH;
1906 #endif
1907
1908         if (dh_tmp_export)
1909                 emask_k|=SSL_kEDH;
1910
1911         if (dh_tmp)
1912                 mask_k|=SSL_kEDH;
1913
1914         if (dh_rsa) mask_k|=SSL_kDHr;
1915         if (dh_rsa_export) emask_k|=SSL_kDHr;
1916
1917         if (dh_dsa) mask_k|=SSL_kDHd;
1918         if (dh_dsa_export) emask_k|=SSL_kDHd;
1919
1920         if (rsa_enc || rsa_sign)
1921                 {
1922                 mask_a|=SSL_aRSA;
1923                 emask_a|=SSL_aRSA;
1924                 }
1925
1926         if (dsa_sign)
1927                 {
1928                 mask_a|=SSL_aDSS;
1929                 emask_a|=SSL_aDSS;
1930                 }
1931
1932         mask_a|=SSL_aNULL;
1933         emask_a|=SSL_aNULL;
1934
1935 #ifndef OPENSSL_NO_KRB5
1936         mask_k|=SSL_kKRB5;
1937         mask_a|=SSL_aKRB5;
1938         emask_k|=SSL_kKRB5;
1939         emask_a|=SSL_aKRB5;
1940 #endif
1941
1942         /* An ECC certificate may be usable for ECDH and/or
1943          * ECDSA cipher suites depending on the key usage extension.
1944          */
1945         if (have_ecc_cert)
1946                 {
1947                 /* This call populates extension flags (ex_flags) */
1948                 x = (c->pkeys[SSL_PKEY_ECC]).x509;
1949                 X509_check_purpose(x, -1, 0);
1950                 ecdh_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
1951                     (x->ex_kusage & X509v3_KU_KEY_AGREEMENT) : 1;
1952                 ecdsa_ok = (x->ex_flags & EXFLAG_KUSAGE) ?
1953                     (x->ex_kusage & X509v3_KU_DIGITAL_SIGNATURE) : 1;
1954                 ecc_pkey = X509_get_pubkey(x);
1955                 ecc_pkey_size = (ecc_pkey != NULL) ?
1956                     EVP_PKEY_bits(ecc_pkey) : 0;
1957                 EVP_PKEY_free(ecc_pkey);
1958                 if ((x->sig_alg) && (x->sig_alg->algorithm))
1959                         signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
1960 #ifndef OPENSSL_NO_ECDH
1961                 if (ecdh_ok)
1962                         {
1963                         const char *sig = OBJ_nid2ln(signature_nid);
1964                         if (sig == NULL)
1965                                 {
1966                                 ERR_clear_error();
1967                                 sig = "unknown";
1968                                 }
1969                                 
1970                         if (strstr(sig, "WithRSA"))
1971                                 {
1972                                 mask_k|=SSL_kECDHr;
1973                                 mask_a|=SSL_aECDH;
1974                                 if (ecc_pkey_size <= 163)
1975                                         {
1976                                         emask_k|=SSL_kECDHr;
1977                                         emask_a|=SSL_aECDH;
1978                                         }
1979                                 }
1980
1981                         if (signature_nid == NID_ecdsa_with_SHA1)
1982                                 {
1983                                 mask_k|=SSL_kECDHe;
1984                                 mask_a|=SSL_aECDH;
1985                                 if (ecc_pkey_size <= 163)
1986                                         {
1987                                         emask_k|=SSL_kECDHe;
1988                                         emask_a|=SSL_aECDH;
1989                                         }
1990                                 }
1991                         }
1992 #endif
1993 #ifndef OPENSSL_NO_ECDSA
1994                 if (ecdsa_ok)
1995                         {
1996                         mask_a|=SSL_aECDSA;
1997                         emask_a|=SSL_aECDSA;
1998                         }
1999 #endif
2000                 }
2001
2002 #ifndef OPENSSL_NO_ECDH
2003         if (have_ecdh_tmp)
2004                 {
2005                 mask_k|=SSL_kEECDH;
2006                 emask_k|=SSL_kEECDH;
2007                 }
2008 #endif
2009
2010 #ifndef OPENSSL_NO_PSK
2011         mask_k |= SSL_kPSK;
2012         mask_a |= SSL_aPSK;
2013         emask_k |= SSL_kPSK;
2014         emask_a |= SSL_aPSK;
2015 #endif
2016
2017         c->mask_k=mask_k;
2018         c->mask_a=mask_a;
2019         c->export_mask_k=emask_k;
2020         c->export_mask_a=emask_a;
2021         c->valid=1;
2022         }
2023
2024 /* This handy macro borrowed from crypto/x509v3/v3_purp.c */
2025 #define ku_reject(x, usage) \
2026         (((x)->ex_flags & EXFLAG_KUSAGE) && !((x)->ex_kusage & (usage)))
2027
2028 #ifndef OPENSSL_NO_EC
2029
2030 int ssl_check_srvr_ecc_cert_and_alg(X509 *x, const SSL_CIPHER *cs)
2031         {
2032         unsigned long alg_k, alg_a;
2033         EVP_PKEY *pkey = NULL;
2034         int keysize = 0;
2035         int signature_nid = 0;
2036
2037         alg_k = cs->algorithm_mkey;
2038         alg_a = cs->algorithm_auth;
2039
2040         if (SSL_C_IS_EXPORT(cs))
2041                 {
2042                 /* ECDH key length in export ciphers must be <= 163 bits */
2043                 pkey = X509_get_pubkey(x);
2044                 if (pkey == NULL) return 0;
2045                 keysize = EVP_PKEY_bits(pkey);
2046                 EVP_PKEY_free(pkey);
2047                 if (keysize > 163) return 0;
2048                 }
2049
2050         /* This call populates the ex_flags field correctly */
2051         X509_check_purpose(x, -1, 0);
2052         if ((x->sig_alg) && (x->sig_alg->algorithm))
2053                 signature_nid = OBJ_obj2nid(x->sig_alg->algorithm);
2054         if (alg_k & SSL_kECDHe || alg_k & SSL_kECDHr)
2055                 {
2056                 /* key usage, if present, must allow key agreement */
2057                 if (ku_reject(x, X509v3_KU_KEY_AGREEMENT))
2058                         {
2059                         SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_KEY_AGREEMENT);
2060                         return 0;
2061                         }
2062                 if (alg_k & SSL_kECDHe)
2063                         {
2064                         /* signature alg must be ECDSA */
2065                         if (signature_nid != NID_ecdsa_with_SHA1)
2066                                 {
2067                                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_SHA1_SIGNATURE);
2068                                 return 0;
2069                                 }
2070                         }
2071                 if (alg_k & SSL_kECDHr)
2072                         {
2073                         /* signature alg must be RSA */
2074
2075                         const char *sig = OBJ_nid2ln(signature_nid);
2076                         if (sig == NULL)
2077                                 {
2078                                 ERR_clear_error();
2079                                 sig = "unknown";
2080                                 }
2081                         if (strstr(sig, "WithRSA") == NULL)
2082                                 {
2083                                 SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_SHOULD_HAVE_RSA_SIGNATURE);
2084                                 return 0;
2085                                 }
2086                         }
2087                 }
2088         if (alg_a & SSL_aECDSA)
2089                 {
2090                 /* key usage, if present, must allow signing */
2091                 if (ku_reject(x, X509v3_KU_DIGITAL_SIGNATURE))
2092                         {
2093                         SSLerr(SSL_F_SSL_CHECK_SRVR_ECC_CERT_AND_ALG, SSL_R_ECC_CERT_NOT_FOR_SIGNING);
2094                         return 0;
2095                         }
2096                 }
2097
2098         return 1;  /* all checks are ok */
2099         }
2100
2101 #endif
2102
2103 /* THIS NEEDS CLEANING UP */
2104 X509 *ssl_get_server_send_cert(SSL *s)
2105         {
2106         unsigned long alg_k,alg_a,mask_k,mask_a;
2107         CERT *c;
2108         int i,is_export;
2109
2110         c=s->cert;
2111         ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
2112         is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
2113         if (is_export)
2114                 {
2115                 mask_k = c->export_mask_k;
2116                 mask_a = c->export_mask_a;
2117                 }
2118         else
2119                 {
2120                 mask_k = c->mask_k;
2121                 mask_a = c->mask_a;
2122                 }
2123         
2124         alg_k = s->s3->tmp.new_cipher->algorithm_mkey;
2125         alg_a = s->s3->tmp.new_cipher->algorithm_auth;
2126
2127         if (alg_k & (SSL_kECDHr|SSL_kECDHe))
2128                 {
2129                 /* we don't need to look at SSL_kEECDH
2130                  * since no certificate is needed for
2131                  * anon ECDH and for authenticated
2132                  * EECDH, the check for the auth
2133                  * algorithm will set i correctly
2134                  * NOTE: For ECDH-RSA, we need an ECC
2135                  * not an RSA cert but for EECDH-RSA
2136                  * we need an RSA cert. Placing the
2137                  * checks for SSL_kECDH before RSA
2138                  * checks ensures the correct cert is chosen.
2139                  */
2140                 i=SSL_PKEY_ECC;
2141                 }
2142         else if (alg_a & SSL_aECDSA)
2143                 {
2144                 i=SSL_PKEY_ECC;
2145                 }
2146         else if (alg_k & SSL_kDHr)
2147                 i=SSL_PKEY_DH_RSA;
2148         else if (alg_k & SSL_kDHd)
2149                 i=SSL_PKEY_DH_DSA;
2150         else if (alg_a & SSL_aDSS)
2151                 i=SSL_PKEY_DSA_SIGN;
2152         else if (alg_a & SSL_aRSA)
2153                 {
2154                 if (c->pkeys[SSL_PKEY_RSA_ENC].x509 == NULL)
2155                         i=SSL_PKEY_RSA_SIGN;
2156                 else
2157                         i=SSL_PKEY_RSA_ENC;
2158                 }
2159         else if (alg_a & SSL_aKRB5)
2160                 {
2161                 /* VRS something else here? */
2162                 return(NULL);
2163                 }
2164         else if (alg_a & SSL_aGOST94) 
2165                 i=SSL_PKEY_GOST94;
2166         else if (alg_a & SSL_aGOST01)
2167                 i=SSL_PKEY_GOST01;
2168         else /* if (alg_a & SSL_aNULL) */
2169                 {
2170                 SSLerr(SSL_F_SSL_GET_SERVER_SEND_CERT,ERR_R_INTERNAL_ERROR);
2171                 return(NULL);
2172                 }
2173         if (c->pkeys[i].x509 == NULL) return(NULL);
2174
2175         return(c->pkeys[i].x509);
2176         }
2177
2178 EVP_PKEY *ssl_get_sign_pkey(SSL *s,const SSL_CIPHER *cipher)
2179         {
2180         unsigned long alg_a;
2181         CERT *c;
2182
2183         alg_a = cipher->algorithm_auth;
2184         c=s->cert;
2185
2186         if ((alg_a & SSL_aDSS) &&
2187                 (c->pkeys[SSL_PKEY_DSA_SIGN].privatekey != NULL))
2188                 return(c->pkeys[SSL_PKEY_DSA_SIGN].privatekey);
2189         else if (alg_a & SSL_aRSA)
2190                 {
2191                 if (c->pkeys[SSL_PKEY_RSA_SIGN].privatekey != NULL)
2192                         return(c->pkeys[SSL_PKEY_RSA_SIGN].privatekey);
2193                 else if (c->pkeys[SSL_PKEY_RSA_ENC].privatekey != NULL)
2194                         return(c->pkeys[SSL_PKEY_RSA_ENC].privatekey);
2195                 else
2196                         return(NULL);
2197                 }
2198         else if ((alg_a & SSL_aECDSA) &&
2199                  (c->pkeys[SSL_PKEY_ECC].privatekey != NULL))
2200                 return(c->pkeys[SSL_PKEY_ECC].privatekey);
2201         else /* if (alg_a & SSL_aNULL) */
2202                 {
2203                 SSLerr(SSL_F_SSL_GET_SIGN_PKEY,ERR_R_INTERNAL_ERROR);
2204                 return(NULL);
2205                 }
2206         }
2207
2208 void ssl_update_cache(SSL *s,int mode)
2209         {
2210         int i;
2211
2212         /* If the session_id_length is 0, we are not supposed to cache it,
2213          * and it would be rather hard to do anyway :-) */
2214         if (s->session->session_id_length == 0) return;
2215
2216         i=s->session_ctx->session_cache_mode;
2217         if ((i & mode) && (!s->hit)
2218                 && ((i & SSL_SESS_CACHE_NO_INTERNAL_STORE)
2219                     || SSL_CTX_add_session(s->session_ctx,s->session))
2220                 && (s->session_ctx->new_session_cb != NULL))
2221                 {
2222                 CRYPTO_add(&s->session->references,1,CRYPTO_LOCK_SSL_SESSION);
2223                 if (!s->session_ctx->new_session_cb(s,s->session))
2224                         SSL_SESSION_free(s->session);
2225                 }
2226
2227         /* auto flush every 255 connections */
2228         if ((!(i & SSL_SESS_CACHE_NO_AUTO_CLEAR)) &&
2229                 ((i & mode) == mode))
2230                 {
2231                 if (  (((mode & SSL_SESS_CACHE_CLIENT)
2232                         ?s->session_ctx->stats.sess_connect_good
2233                         :s->session_ctx->stats.sess_accept_good) & 0xff) == 0xff)
2234                         {
2235                         SSL_CTX_flush_sessions(s->session_ctx,(unsigned long)time(NULL));
2236                         }
2237                 }
2238         }
2239
2240 const SSL_METHOD *SSL_get_ssl_method(SSL *s)
2241         {
2242         return(s->method);
2243         }
2244
2245 int SSL_set_ssl_method(SSL *s, const SSL_METHOD *meth)
2246         {
2247         int conn= -1;
2248         int ret=1;
2249
2250         if (s->method != meth)
2251                 {
2252                 if (s->handshake_func != NULL)
2253                         conn=(s->handshake_func == s->method->ssl_connect);
2254
2255                 if (s->method->version == meth->version)
2256                         s->method=meth;
2257                 else
2258                         {
2259                         s->method->ssl_free(s);
2260                         s->method=meth;
2261                         ret=s->method->ssl_new(s);
2262                         }
2263
2264                 if (conn == 1)
2265                         s->handshake_func=meth->ssl_connect;
2266                 else if (conn == 0)
2267                         s->handshake_func=meth->ssl_accept;
2268                 }
2269         return(ret);
2270         }
2271
2272 int SSL_get_error(const SSL *s,int i)
2273         {
2274         int reason;
2275         unsigned long l;
2276         BIO *bio;
2277
2278         if (i > 0) return(SSL_ERROR_NONE);
2279
2280         /* Make things return SSL_ERROR_SYSCALL when doing SSL_do_handshake
2281          * etc, where we do encode the error */
2282         if ((l=ERR_peek_error()) != 0)
2283                 {
2284                 if (ERR_GET_LIB(l) == ERR_LIB_SYS)
2285                         return(SSL_ERROR_SYSCALL);
2286                 else
2287                         return(SSL_ERROR_SSL);
2288                 }
2289
2290         if ((i < 0) && SSL_want_read(s))
2291                 {
2292                 bio=SSL_get_rbio(s);
2293                 if (BIO_should_read(bio))
2294                         return(SSL_ERROR_WANT_READ);
2295                 else if (BIO_should_write(bio))
2296                         /* This one doesn't make too much sense ... We never try
2297                          * to write to the rbio, and an application program where
2298                          * rbio and wbio are separate couldn't even know what it
2299                          * should wait for.
2300                          * However if we ever set s->rwstate incorrectly
2301                          * (so that we have SSL_want_read(s) instead of
2302                          * SSL_want_write(s)) and rbio and wbio *are* the same,
2303                          * this test works around that bug; so it might be safer
2304                          * to keep it. */
2305                         return(SSL_ERROR_WANT_WRITE);
2306                 else if (BIO_should_io_special(bio))
2307                         {
2308                         reason=BIO_get_retry_reason(bio);
2309                         if (reason == BIO_RR_CONNECT)
2310                                 return(SSL_ERROR_WANT_CONNECT);
2311                         else if (reason == BIO_RR_ACCEPT)
2312                                 return(SSL_ERROR_WANT_ACCEPT);
2313                         else
2314                                 return(SSL_ERROR_SYSCALL); /* unknown */
2315                         }
2316                 }
2317
2318         if ((i < 0) && SSL_want_write(s))
2319                 {
2320                 bio=SSL_get_wbio(s);
2321                 if (BIO_should_write(bio))
2322                         return(SSL_ERROR_WANT_WRITE);
2323                 else if (BIO_should_read(bio))
2324                         /* See above (SSL_want_read(s) with BIO_should_write(bio)) */
2325                         return(SSL_ERROR_WANT_READ);
2326                 else if (BIO_should_io_special(bio))
2327                         {
2328                         reason=BIO_get_retry_reason(bio);
2329                         if (reason == BIO_RR_CONNECT)
2330                                 return(SSL_ERROR_WANT_CONNECT);
2331                         else if (reason == BIO_RR_ACCEPT)
2332                                 return(SSL_ERROR_WANT_ACCEPT);
2333                         else
2334                                 return(SSL_ERROR_SYSCALL);
2335                         }
2336                 }
2337         if ((i < 0) && SSL_want_x509_lookup(s))
2338                 {
2339                 return(SSL_ERROR_WANT_X509_LOOKUP);
2340                 }
2341
2342         if (i == 0)
2343                 {
2344                 if (s->version == SSL2_VERSION)
2345                         {
2346                         /* assume it is the socket being closed */
2347                         return(SSL_ERROR_ZERO_RETURN);
2348                         }
2349                 else
2350                         {
2351                         if ((s->shutdown & SSL_RECEIVED_SHUTDOWN) &&
2352                                 (s->s3->warn_alert == SSL_AD_CLOSE_NOTIFY))
2353                                 return(SSL_ERROR_ZERO_RETURN);
2354                         }
2355                 }
2356         return(SSL_ERROR_SYSCALL);
2357         }
2358
2359 int SSL_do_handshake(SSL *s)
2360         {
2361         int ret=1;
2362
2363         if (s->handshake_func == NULL)
2364                 {
2365                 SSLerr(SSL_F_SSL_DO_HANDSHAKE,SSL_R_CONNECTION_TYPE_NOT_SET);
2366                 return(-1);
2367                 }
2368
2369         s->method->ssl_renegotiate_check(s);
2370
2371         if (SSL_in_init(s) || SSL_in_before(s))
2372                 {
2373                 ret=s->handshake_func(s);
2374                 }
2375         return(ret);
2376         }
2377
2378 /* For the next 2 functions, SSL_clear() sets shutdown and so
2379  * one of these calls will reset it */
2380 void SSL_set_accept_state(SSL *s)
2381         {
2382         s->server=1;
2383         s->shutdown=0;
2384         s->state=SSL_ST_ACCEPT|SSL_ST_BEFORE;
2385         s->handshake_func=s->method->ssl_accept;
2386         /* clear the current cipher */
2387         ssl_clear_cipher_ctx(s);
2388         ssl_clear_hash_ctx(&s->read_hash);
2389         ssl_clear_hash_ctx(&s->write_hash);
2390         }
2391
2392 void SSL_set_connect_state(SSL *s)
2393         {
2394         s->server=0;
2395         s->shutdown=0;
2396         s->state=SSL_ST_CONNECT|SSL_ST_BEFORE;
2397         s->handshake_func=s->method->ssl_connect;
2398         /* clear the current cipher */
2399         ssl_clear_cipher_ctx(s);
2400         ssl_clear_hash_ctx(&s->read_hash);
2401         ssl_clear_hash_ctx(&s->write_hash);
2402         }
2403
2404 int ssl_undefined_function(SSL *s)
2405         {
2406         SSLerr(SSL_F_SSL_UNDEFINED_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2407         return(0);
2408         }
2409
2410 int ssl_undefined_void_function(void)
2411         {
2412         SSLerr(SSL_F_SSL_UNDEFINED_VOID_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2413         return(0);
2414         }
2415
2416 int ssl_undefined_const_function(const SSL *s)
2417         {
2418         SSLerr(SSL_F_SSL_UNDEFINED_CONST_FUNCTION,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2419         return(0);
2420         }
2421
2422 SSL_METHOD *ssl_bad_method(int ver)
2423         {
2424         SSLerr(SSL_F_SSL_BAD_METHOD,ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
2425         return(NULL);
2426         }
2427
2428 const char *SSL_get_version(const SSL *s)
2429         {
2430         if (s->version == TLS1_1_VERSION)
2431                 return("TLSv1.1");
2432         else if (s->version == SSL3_VERSION)
2433                 return("SSLv3");
2434         else if (s->version == SSL3_VERSION)
2435                 return("SSLv3");
2436         else if (s->version == SSL2_VERSION)
2437                 return("SSLv2");
2438         else
2439                 return("unknown");
2440         }
2441
2442 SSL *SSL_dup(SSL *s)
2443         {
2444         STACK_OF(X509_NAME) *sk;
2445         X509_NAME *xn;
2446         SSL *ret;
2447         int i;
2448         
2449         if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
2450             return(NULL);
2451
2452         ret->version = s->version;
2453         ret->type = s->type;
2454         ret->method = s->method;
2455
2456         if (s->session != NULL)
2457                 {
2458                 /* This copies session-id, SSL_METHOD, sid_ctx, and 'cert' */
2459                 SSL_copy_session_id(ret,s);
2460                 }
2461         else
2462                 {
2463                 /* No session has been established yet, so we have to expect
2464                  * that s->cert or ret->cert will be changed later --
2465                  * they should not both point to the same object,
2466                  * and thus we can't use SSL_copy_session_id. */
2467
2468                 ret->method->ssl_free(ret);
2469                 ret->method = s->method;
2470                 ret->method->ssl_new(ret);
2471
2472                 if (s->cert != NULL)
2473                         {
2474                         if (ret->cert != NULL)
2475                                 {
2476                                 ssl_cert_free(ret->cert);
2477                                 }
2478                         ret->cert = ssl_cert_dup(s->cert);
2479                         if (ret->cert == NULL)
2480                                 goto err;
2481                         }
2482                                 
2483                 SSL_set_session_id_context(ret,
2484                         s->sid_ctx, s->sid_ctx_length);
2485                 }
2486
2487         ret->options=s->options;
2488         ret->mode=s->mode;
2489         SSL_set_max_cert_list(ret,SSL_get_max_cert_list(s));
2490         SSL_set_read_ahead(ret,SSL_get_read_ahead(s));
2491         ret->msg_callback = s->msg_callback;
2492         ret->msg_callback_arg = s->msg_callback_arg;
2493         SSL_set_verify(ret,SSL_get_verify_mode(s),
2494                 SSL_get_verify_callback(s));
2495         SSL_set_verify_depth(ret,SSL_get_verify_depth(s));
2496         ret->generate_session_id = s->generate_session_id;
2497
2498         SSL_set_info_callback(ret,SSL_get_info_callback(s));
2499         
2500         ret->debug=s->debug;
2501
2502         /* copy app data, a little dangerous perhaps */
2503         if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_SSL, &ret->ex_data, &s->ex_data))
2504                 goto err;
2505
2506         /* setup rbio, and wbio */
2507         if (s->rbio != NULL)
2508                 {
2509                 if (!BIO_dup_state(s->rbio,(char *)&ret->rbio))
2510                         goto err;
2511                 }
2512         if (s->wbio != NULL)
2513                 {
2514                 if (s->wbio != s->rbio)
2515                         {
2516                         if (!BIO_dup_state(s->wbio,(char *)&ret->wbio))
2517                                 goto err;
2518                         }
2519                 else
2520                         ret->wbio=ret->rbio;
2521                 }
2522         ret->rwstate = s->rwstate;
2523         ret->in_handshake = s->in_handshake;
2524         ret->handshake_func = s->handshake_func;
2525         ret->server = s->server;
2526         ret->new_session = s->new_session;
2527         ret->quiet_shutdown = s->quiet_shutdown;
2528         ret->shutdown=s->shutdown;
2529         ret->state=s->state; /* SSL_dup does not really work at any state, though */
2530         ret->rstate=s->rstate;
2531         ret->init_num = 0; /* would have to copy ret->init_buf, ret->init_msg, ret->init_num, ret->init_off */
2532         ret->hit=s->hit;
2533
2534         X509_VERIFY_PARAM_inherit(ret->param, s->param);
2535
2536         /* dup the cipher_list and cipher_list_by_id stacks */
2537         if (s->cipher_list != NULL)
2538                 {
2539                 if ((ret->cipher_list=sk_SSL_CIPHER_dup(s->cipher_list)) == NULL)
2540                         goto err;
2541                 }
2542         if (s->cipher_list_by_id != NULL)
2543                 if ((ret->cipher_list_by_id=sk_SSL_CIPHER_dup(s->cipher_list_by_id))
2544                         == NULL)
2545                         goto err;
2546
2547         /* Dup the client_CA list */
2548         if (s->client_CA != NULL)
2549                 {
2550                 if ((sk=sk_X509_NAME_dup(s->client_CA)) == NULL) goto err;
2551                 ret->client_CA=sk;
2552                 for (i=0; i<sk_X509_NAME_num(sk); i++)
2553                         {
2554                         xn=sk_X509_NAME_value(sk,i);
2555                         if (sk_X509_NAME_set(sk,i,X509_NAME_dup(xn)) == NULL)
2556                                 {
2557                                 X509_NAME_free(xn);
2558                                 goto err;
2559                                 }
2560                         }
2561                 }
2562
2563         if (0)
2564                 {
2565 err:
2566                 if (ret != NULL) SSL_free(ret);
2567                 ret=NULL;
2568                 }
2569         return(ret);
2570         }
2571
2572 void ssl_clear_cipher_ctx(SSL *s)
2573         {
2574         if (s->enc_read_ctx != NULL)
2575                 {
2576                 EVP_CIPHER_CTX_cleanup(s->enc_read_ctx);
2577                 OPENSSL_free(s->enc_read_ctx);
2578                 s->enc_read_ctx=NULL;
2579                 }
2580         if (s->enc_write_ctx != NULL)
2581                 {
2582                 EVP_CIPHER_CTX_cleanup(s->enc_write_ctx);
2583                 OPENSSL_free(s->enc_write_ctx);
2584                 s->enc_write_ctx=NULL;
2585                 }
2586 #ifndef OPENSSL_NO_COMP
2587         if (s->expand != NULL)
2588                 {
2589                 COMP_CTX_free(s->expand);
2590                 s->expand=NULL;
2591                 }
2592         if (s->compress != NULL)
2593                 {
2594                 COMP_CTX_free(s->compress);
2595                 s->compress=NULL;
2596                 }
2597 #endif
2598         }
2599
2600 /* Fix this function so that it takes an optional type parameter */
2601 X509 *SSL_get_certificate(const SSL *s)
2602         {
2603         if (s->cert != NULL)
2604                 return(s->cert->key->x509);
2605         else
2606                 return(NULL);
2607         }
2608
2609 /* Fix this function so that it takes an optional type parameter */
2610 EVP_PKEY *SSL_get_privatekey(SSL *s)
2611         {
2612         if (s->cert != NULL)
2613                 return(s->cert->key->privatekey);
2614         else
2615                 return(NULL);
2616         }
2617
2618 const SSL_CIPHER *SSL_get_current_cipher(const SSL *s)
2619         {
2620         if ((s->session != NULL) && (s->session->cipher != NULL))
2621                 return(s->session->cipher);
2622         return(NULL);
2623         }
2624 #ifdef OPENSSL_NO_COMP
2625 const void *SSL_get_current_compression(SSL *s)
2626         {
2627         return NULL;
2628         }
2629 const void *SSL_get_current_expansion(SSL *s)
2630         {
2631         return NULL;
2632         }
2633 #else
2634
2635 const COMP_METHOD *SSL_get_current_compression(SSL *s)
2636         {
2637         if (s->compress != NULL)
2638                 return(s->compress->meth);
2639         return(NULL);
2640         }
2641
2642 const COMP_METHOD *SSL_get_current_expansion(SSL *s)
2643         {
2644         if (s->expand != NULL)
2645                 return(s->expand->meth);
2646         return(NULL);
2647         }
2648 #endif
2649
2650 int ssl_init_wbio_buffer(SSL *s,int push)
2651         {
2652         BIO *bbio;
2653
2654         if (s->bbio == NULL)
2655                 {
2656                 bbio=BIO_new(BIO_f_buffer());
2657                 if (bbio == NULL) return(0);
2658                 s->bbio=bbio;
2659                 }
2660         else
2661                 {
2662                 bbio=s->bbio;
2663                 if (s->bbio == s->wbio)
2664                         s->wbio=BIO_pop(s->wbio);
2665                 }
2666         (void)BIO_reset(bbio);
2667 /*      if (!BIO_set_write_buffer_size(bbio,16*1024)) */
2668         if (!BIO_set_read_buffer_size(bbio,1))
2669                 {
2670                 SSLerr(SSL_F_SSL_INIT_WBIO_BUFFER,ERR_R_BUF_LIB);
2671                 return(0);
2672                 }
2673         if (push)
2674                 {
2675                 if (s->wbio != bbio)
2676                         s->wbio=BIO_push(bbio,s->wbio);
2677                 }
2678         else
2679                 {
2680                 if (s->wbio == bbio)
2681                         s->wbio=BIO_pop(bbio);
2682                 }
2683         return(1);
2684         }
2685
2686 void ssl_free_wbio_buffer(SSL *s)
2687         {
2688         if (s->bbio == NULL) return;
2689
2690         if (s->bbio == s->wbio)
2691                 {
2692                 /* remove buffering */
2693                 s->wbio=BIO_pop(s->wbio);
2694 #ifdef REF_CHECK /* not the usual REF_CHECK, but this avoids adding one more preprocessor symbol */
2695                 assert(s->wbio != NULL);
2696 #endif
2697         }
2698         BIO_free(s->bbio);
2699         s->bbio=NULL;
2700         }
2701         
2702 void SSL_CTX_set_quiet_shutdown(SSL_CTX *ctx,int mode)
2703         {
2704         ctx->quiet_shutdown=mode;
2705         }
2706
2707 int SSL_CTX_get_quiet_shutdown(const SSL_CTX *ctx)
2708         {
2709         return(ctx->quiet_shutdown);
2710         }
2711
2712 void SSL_set_quiet_shutdown(SSL *s,int mode)
2713         {
2714         s->quiet_shutdown=mode;
2715         }
2716
2717 int SSL_get_quiet_shutdown(const SSL *s)
2718         {
2719         return(s->quiet_shutdown);
2720         }
2721
2722 void SSL_set_shutdown(SSL *s,int mode)
2723         {
2724         s->shutdown=mode;
2725         }
2726
2727 int SSL_get_shutdown(const SSL *s)
2728         {
2729         return(s->shutdown);
2730         }
2731
2732 int SSL_version(const SSL *s)
2733         {
2734         return(s->version);
2735         }
2736
2737 SSL_CTX *SSL_get_SSL_CTX(const SSL *ssl)
2738         {
2739         return(ssl->ctx);
2740         }
2741
2742 SSL_CTX *SSL_set_SSL_CTX(SSL *ssl, SSL_CTX* ctx)
2743         {
2744         if (ssl->ctx == ctx)
2745                 return ssl->ctx;
2746 #ifndef OPENSSL_NO_TLSEXT
2747         if (ctx == NULL)
2748                 ctx = ssl->initial_ctx;
2749 #endif
2750         if (ssl->cert != NULL)
2751                 ssl_cert_free(ssl->cert);
2752         ssl->cert = ssl_cert_dup(ctx->cert);
2753         CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
2754         if (ssl->ctx != NULL)
2755                 SSL_CTX_free(ssl->ctx); /* decrement reference count */
2756         ssl->ctx = ctx;
2757         return(ssl->ctx);
2758         }
2759
2760 #ifndef OPENSSL_NO_STDIO
2761 int SSL_CTX_set_default_verify_paths(SSL_CTX *ctx)
2762         {
2763         return(X509_STORE_set_default_paths(ctx->cert_store));
2764         }
2765
2766 int SSL_CTX_load_verify_locations(SSL_CTX *ctx, const char *CAfile,
2767                 const char *CApath)
2768         {
2769         return(X509_STORE_load_locations(ctx->cert_store,CAfile,CApath));
2770         }
2771 #endif
2772
2773 void SSL_set_info_callback(SSL *ssl,
2774         void (*cb)(const SSL *ssl,int type,int val))
2775         {
2776         ssl->info_callback=cb;
2777         }
2778
2779 /* One compiler (Diab DCC) doesn't like argument names in returned
2780    function pointer.  */
2781 void (*SSL_get_info_callback(const SSL *ssl))(const SSL * /*ssl*/,int /*type*/,int /*val*/)
2782         {
2783         return ssl->info_callback;
2784         }
2785
2786 int SSL_state(const SSL *ssl)
2787         {
2788         return(ssl->state);
2789         }
2790
2791 void SSL_set_verify_result(SSL *ssl,long arg)
2792         {
2793         ssl->verify_result=arg;
2794         }
2795
2796 long SSL_get_verify_result(const SSL *ssl)
2797         {
2798         return(ssl->verify_result);
2799         }
2800
2801 int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
2802                          CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
2803         {
2804         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL, argl, argp,
2805                                 new_func, dup_func, free_func);
2806         }
2807
2808 int SSL_set_ex_data(SSL *s,int idx,void *arg)
2809         {
2810         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
2811         }
2812
2813 void *SSL_get_ex_data(const SSL *s,int idx)
2814         {
2815         return(CRYPTO_get_ex_data(&s->ex_data,idx));
2816         }
2817
2818 int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
2819                              CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
2820         {
2821         return CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_SSL_CTX, argl, argp,
2822                                 new_func, dup_func, free_func);
2823         }
2824
2825 int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
2826         {
2827         return(CRYPTO_set_ex_data(&s->ex_data,idx,arg));
2828         }
2829
2830 void *SSL_CTX_get_ex_data(const SSL_CTX *s,int idx)
2831         {
2832         return(CRYPTO_get_ex_data(&s->ex_data,idx));
2833         }
2834
2835 int ssl_ok(SSL *s)
2836         {
2837         return(1);
2838         }
2839
2840 X509_STORE *SSL_CTX_get_cert_store(const SSL_CTX *ctx)
2841         {
2842         return(ctx->cert_store);
2843         }
2844
2845 void SSL_CTX_set_cert_store(SSL_CTX *ctx,X509_STORE *store)
2846         {
2847         if (ctx->cert_store != NULL)
2848                 X509_STORE_free(ctx->cert_store);
2849         ctx->cert_store=store;
2850         }
2851
2852 int SSL_want(const SSL *s)
2853         {
2854         return(s->rwstate);
2855         }
2856
2857 /*!
2858  * \brief Set the callback for generating temporary RSA keys.
2859  * \param ctx the SSL context.
2860  * \param cb the callback
2861  */
2862
2863 #ifndef OPENSSL_NO_RSA
2864 void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
2865                                                           int is_export,
2866                                                           int keylength))
2867     {
2868     SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2869     }
2870
2871 void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
2872                                                   int is_export,
2873                                                   int keylength))
2874     {
2875     SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)(void))cb);
2876     }
2877 #endif
2878
2879 #ifdef DOXYGEN
2880 /*!
2881  * \brief The RSA temporary key callback function.
2882  * \param ssl the SSL session.
2883  * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
2884  * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
2885  * of the required key in bits.
2886  * \return the temporary RSA key.
2887  * \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
2888  */
2889
2890 RSA *cb(SSL *ssl,int is_export,int keylength)
2891     {}
2892 #endif
2893
2894 /*!
2895  * \brief Set the callback for generating temporary DH keys.
2896  * \param ctx the SSL context.
2897  * \param dh the callback
2898  */
2899
2900 #ifndef OPENSSL_NO_DH
2901 void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
2902                                                         int keylength))
2903         {
2904         SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2905         }
2906
2907 void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
2908                                                 int keylength))
2909         {
2910         SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)(void))dh);
2911         }
2912 #endif
2913
2914 #ifndef OPENSSL_NO_ECDH
2915 void SSL_CTX_set_tmp_ecdh_callback(SSL_CTX *ctx,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
2916                                                                 int keylength))
2917         {
2918         SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
2919         }
2920
2921 void SSL_set_tmp_ecdh_callback(SSL *ssl,EC_KEY *(*ecdh)(SSL *ssl,int is_export,
2922                                                         int keylength))
2923         {
2924         SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_ECDH_CB,(void (*)(void))ecdh);
2925         }
2926 #endif
2927
2928 #ifndef OPENSSL_NO_PSK
2929 int SSL_CTX_use_psk_identity_hint(SSL_CTX *ctx, const char *identity_hint)
2930         {
2931         if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
2932                 {
2933                 SSLerr(SSL_F_SSL_CTX_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
2934                 return 0;
2935                 }
2936         if (ctx->psk_identity_hint != NULL)
2937                 OPENSSL_free(ctx->psk_identity_hint);
2938         if (identity_hint != NULL)
2939                 {
2940                 ctx->psk_identity_hint = BUF_strdup(identity_hint);
2941                 if (ctx->psk_identity_hint == NULL)
2942                         return 0;
2943                 }
2944         else
2945                 ctx->psk_identity_hint = NULL;
2946         return 1;
2947         }
2948
2949 int SSL_use_psk_identity_hint(SSL *s, const char *identity_hint)
2950         {
2951         if (s == NULL)
2952                 return 0;
2953
2954         if (s->session == NULL)
2955                 return 1; /* session not created yet, ignored */
2956
2957         if (identity_hint != NULL && strlen(identity_hint) > PSK_MAX_IDENTITY_LEN)
2958                 {
2959                 SSLerr(SSL_F_SSL_USE_PSK_IDENTITY_HINT, SSL_R_DATA_LENGTH_TOO_LONG);
2960                 return 0;
2961                 }
2962         if (s->session->psk_identity_hint != NULL)
2963                 OPENSSL_free(s->session->psk_identity_hint);
2964         if (identity_hint != NULL)
2965                 {
2966                 s->session->psk_identity_hint = BUF_strdup(identity_hint);
2967                 if (s->session->psk_identity_hint == NULL)
2968                         return 0;
2969                 }
2970         else
2971                 s->session->psk_identity_hint = NULL;
2972         return 1;
2973         }
2974
2975 const char *SSL_get_psk_identity_hint(const SSL *s)
2976         {
2977         if (s == NULL || s->session == NULL)
2978                 return NULL;
2979         return(s->session->psk_identity_hint);
2980         }
2981
2982 const char *SSL_get_psk_identity(const SSL *s)
2983         {
2984         if (s == NULL || s->session == NULL)
2985                 return NULL;
2986         return(s->session->psk_identity);
2987         }
2988
2989 void SSL_set_psk_client_callback(SSL *s,
2990     unsigned int (*cb)(SSL *ssl, const char *hint,
2991                        char *identity, unsigned int max_identity_len, unsigned char *psk,
2992                        unsigned int max_psk_len))
2993         {
2994         s->psk_client_callback = cb;
2995         }
2996
2997 void SSL_CTX_set_psk_client_callback(SSL_CTX *ctx,
2998     unsigned int (*cb)(SSL *ssl, const char *hint,
2999                        char *identity, unsigned int max_identity_len, unsigned char *psk,
3000                        unsigned int max_psk_len))
3001         {
3002         ctx->psk_client_callback = cb;
3003         }
3004
3005 void SSL_set_psk_server_callback(SSL *s,
3006     unsigned int (*cb)(SSL *ssl, const char *identity,
3007                        unsigned char *psk, unsigned int max_psk_len))
3008         {
3009         s->psk_server_callback = cb;
3010         }
3011
3012 void SSL_CTX_set_psk_server_callback(SSL_CTX *ctx,
3013     unsigned int (*cb)(SSL *ssl, const char *identity,
3014                        unsigned char *psk, unsigned int max_psk_len))
3015         {
3016         ctx->psk_server_callback = cb;
3017         }
3018 #endif
3019
3020 void SSL_CTX_set_msg_callback(SSL_CTX *ctx, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
3021         {
3022         SSL_CTX_callback_ctrl(ctx, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3023         }
3024 void SSL_set_msg_callback(SSL *ssl, void (*cb)(int write_p, int version, int content_type, const void *buf, size_t len, SSL *ssl, void *arg))
3025         {
3026         SSL_callback_ctrl(ssl, SSL_CTRL_SET_MSG_CALLBACK, (void (*)(void))cb);
3027         }
3028
3029 /* Allocates new EVP_MD_CTX and sets pointer to it into given pointer
3030  * vairable, freeing  EVP_MD_CTX previously stored in that variable, if
3031  * any. If EVP_MD pointer is passed, initializes ctx with this md
3032  * Returns newly allocated ctx;
3033  */
3034
3035 EVP_MD_CTX *ssl_replace_hash(EVP_MD_CTX **hash,const EVP_MD *md) 
3036 {
3037         ssl_clear_hash_ctx(hash);
3038         *hash = EVP_MD_CTX_create();
3039         if (md) EVP_DigestInit_ex(*hash,md,NULL);
3040         return *hash;
3041 }
3042 void ssl_clear_hash_ctx(EVP_MD_CTX **hash) 
3043 {
3044
3045         if (*hash) EVP_MD_CTX_destroy(*hash);
3046         *hash=NULL;
3047 }
3048
3049 #if defined(_WINDLL) && defined(OPENSSL_SYS_WIN16)
3050 #include "../crypto/bio/bss_file.c"
3051 #endif
3052
3053 IMPLEMENT_STACK_OF(SSL_CIPHER)
3054 IMPLEMENT_STACK_OF(SSL_COMP)
3055 IMPLEMENT_OBJ_BSEARCH_GLOBAL_CMP_FN(SSL_CIPHER, SSL_CIPHER,
3056                                     ssl_cipher_id);
3057