#include <stdio.h>
#include <openssl/objects.h>
#include <openssl/lhash.h>
+#include <openssl/x509v3.h>
#include "ssl_locl.h"
-char *SSL_version_str=OPENSSL_VERSION_TEXT;
+const char *SSL_version_str=OPENSSL_VERSION_TEXT;
-static STACK *ssl_meth=NULL;
-static STACK *ssl_ctx_meth=NULL;
+static STACK_OF(CRYPTO_EX_DATA_FUNCS) *ssl_meth=NULL;
+static STACK_OF(CRYPTO_EX_DATA_FUNCS) *ssl_ctx_meth=NULL;
static int ssl_meth_num=0;
static int ssl_ctx_meth_num=0;
-GLOBAL SSL3_ENC_METHOD ssl3_undef_enc_method={
- ssl_undefined_function,
- ssl_undefined_function,
- ssl_undefined_function,
- ssl_undefined_function,
- ssl_undefined_function,
+OPENSSL_GLOBAL SSL3_ENC_METHOD ssl3_undef_enc_method={
+ /* evil casts, but these functions are only called if there's a library bug */
+ (int (*)(SSL *,int))ssl_undefined_function,
+ (int (*)(SSL *, unsigned char *, int))ssl_undefined_function,
ssl_undefined_function,
+ (int (*)(SSL *, unsigned char *, unsigned char *, int))ssl_undefined_function,
+ (int (*)(SSL*, int))ssl_undefined_function,
+ (int (*)(SSL *, EVP_MD_CTX *, EVP_MD_CTX *, const char*, int, unsigned char *))ssl_undefined_function
};
int SSL_clear(SSL *s)
s->hit=0;
s->shutdown=0;
-#if 0
+#if 0 /* Disabled since version 1.10 of this file (early return not
+ * needed because SSL_clear is not called when doing renegotiation) */
/* This is set if we are doing dynamic renegotiation so keep
* the old cipher. It is sort of a SSL_clear_lite :-) */
if (s->new_session) return(1);
+#else
+ if (s->new_session)
+ {
+ SSLerr(SSL_F_SSL_CLEAR,SSL_R_INTERNAL_ERROR);
+ return 0;
+ }
#endif
state=s->state; /* Keep to check if we throw away the session-id */
s->verify_mode=ctx->verify_mode;
s->verify_depth=ctx->verify_depth;
s->verify_callback=ctx->default_verify_callback;
+ s->purpose = ctx->purpose;
+ s->trust = ctx->trust;
CRYPTO_add(&ctx->references,1,CRYPTO_LOCK_SSL_CTX);
s->ctx=ctx;
s->references=1;
s->server=(ctx->method->ssl_accept == ssl_undefined_function)?0:1;
s->options=ctx->options;
+ s->mode=ctx->mode;
SSL_clear(s);
- CRYPTO_new_ex_data(ssl_meth,(char *)s,&s->ex_data);
+ CRYPTO_new_ex_data(ssl_meth,s,&s->ex_data);
return(s);
err:
return 1;
}
+int SSL_CTX_set_purpose(SSL_CTX *s, int purpose)
+{
+ if(X509_PURPOSE_get_by_id(purpose) == -1) {
+ SSLerr(SSL_F_SSL_CTX_SET_PURPOSE, SSL_R_INVALID_PURPOSE);
+ return 0;
+ }
+ s->purpose = purpose;
+ return 1;
+}
+
+int SSL_set_purpose(SSL *s, int purpose)
+{
+ if(X509_PURPOSE_get_by_id(purpose) == -1) {
+ SSLerr(SSL_F_SSL_SET_PURPOSE, SSL_R_INVALID_PURPOSE);
+ return 0;
+ }
+ s->purpose = purpose;
+ return 1;
+}
+
+int SSL_CTX_set_trust(SSL_CTX *s, int trust)
+{
+ if(X509_TRUST_get_by_id(trust) == -1) {
+ SSLerr(SSL_F_SSL_CTX_SET_TRUST, SSL_R_INVALID_TRUST);
+ return 0;
+ }
+ s->trust = trust;
+ return 1;
+}
+
+int SSL_set_trust(SSL *s, int trust)
+{
+ if(X509_TRUST_get_by_id(trust) == -1) {
+ SSLerr(SSL_F_SSL_SET_TRUST, SSL_R_INVALID_TRUST);
+ return 0;
+ }
+ s->trust = trust;
+ return 1;
+}
+
void SSL_free(SSL *s)
{
int i;
if (s->method != NULL) s->method->ssl_free(s);
- Free((char *)s);
+ Free(s);
}
void SSL_set_bio(SSL *s,BIO *rbio,BIO *wbio)
}
#endif
+
+/* return length of latest Finished message we sent, copy to 'buf' */
+size_t SSL_get_finished(SSL *s, void *buf, size_t count)
+ {
+ size_t ret = 0;
+
+ if (s->s3 != NULL)
+ {
+ ret = s->s3->tmp.finish_md_len;
+ if (count > ret)
+ count = ret;
+ memcpy(buf, s->s3->tmp.finish_md, count);
+ }
+ return ret;
+ }
+
+/* return length of latest Finished message we expected, copy to 'buf' */
+size_t SSL_get_peer_finished(SSL *s, void *buf, size_t count)
+ {
+ size_t ret = 0;
+
+ if (s->s3 != NULL)
+ {
+ ret = s->s3->tmp.peer_finish_md_len;
+ if (count > ret)
+ count = ret;
+ memcpy(buf, s->s3->tmp.peer_finish_md, count);
+ }
+ return ret;
+ }
+
+
int SSL_get_verify_mode(SSL *s)
{
return(s->verify_mode);
return(0);
}
if (ssl->cert == NULL)
- return(SSL_CTX_check_private_key(ssl->ctx));
+ {
+ SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
+ return 0;
+ }
if (ssl->cert->key->x509 == NULL)
{
SSLerr(SSL_F_SSL_CHECK_PRIVATE_KEY,SSL_R_NO_CERTIFICATE_ASSIGNED);
int SSL_shutdown(SSL *s)
{
- /* Note that this function behaves different from what one might
+ /* Note that this function behaves differently from what one might
* expect. Return values are 0 for no success (yet),
* 1 for success; but calling it once is usually not enough,
* even if blocking I/O is used (see ssl3_shutdown).
return(l);
case SSL_CTRL_OPTIONS:
return(s->options|=larg);
+ case SSL_CTRL_MODE:
+ return(s->mode|=larg);
default:
return(s->method->ssl_ctrl(s,cmd,larg,parg));
}
}
+long SSL_callback_ctrl(SSL *s, int cmd, void (*fp)())
+ {
+ switch(cmd)
+ {
+ default:
+ return(s->method->ssl_callback_ctrl(s,cmd,fp));
+ }
+ }
+
long SSL_CTX_ctrl(SSL_CTX *ctx,int cmd,long larg,char *parg)
{
long l;
return(ctx->stats.sess_cache_full);
case SSL_CTRL_OPTIONS:
return(ctx->options|=larg);
+ case SSL_CTRL_MODE:
+ return(ctx->mode|=larg);
default:
return(ctx->method->ssl_ctx_ctrl(ctx,cmd,larg,parg));
}
}
+long SSL_CTX_callback_ctrl(SSL_CTX *ctx, int cmd, void (*fp)())
+ {
+ switch(cmd)
+ {
+ default:
+ return(ctx->method->ssl_ctx_callback_ctrl(ctx,cmd,fp));
+ }
+ }
+
int ssl_cipher_id_cmp(SSL_CIPHER *a,SSL_CIPHER *b)
{
long l;
return(c->name);
}
-/** specify the ciphers to be used by defaut by the SSL_CTX */
-int SSL_CTX_set_cipher_list(SSL_CTX *ctx,char *str)
+/** specify the ciphers to be used by default by the SSL_CTX */
+int SSL_CTX_set_cipher_list(SSL_CTX *ctx, const char *str)
{
STACK_OF(SSL_CIPHER) *sk;
}
/** specify the ciphers to be used by the SSL */
-int SSL_set_cipher_list(SSL *s,char *str)
+int SSL_set_cipher_list(SSL *s,const char *str)
{
STACK_OF(SSL_CIPHER) *sk;
goto err;
ret->default_passwd_callback=NULL;
+ ret->default_passwd_callback_userdata=NULL;
ret->client_cert_cb=NULL;
ret->sessions=lh_new(SSL_SESSION_hash,SSL_SESSION_cmp);
sk_X509_pop_free(a->extra_certs,X509_free);
if (a->comp_methods != NULL)
sk_SSL_COMP_pop_free(a->comp_methods,SSL_COMP_free);
- Free((char *)a);
+ Free(a);
}
void SSL_CTX_set_default_passwd_cb(SSL_CTX *ctx, pem_password_cb *cb)
ctx->default_passwd_callback=cb;
}
-void SSL_CTX_set_cert_verify_cb(SSL_CTX *ctx,int (*cb)(),char *arg)
+void SSL_CTX_set_default_passwd_cb_userdata(SSL_CTX *ctx,void *u)
{
+ ctx->default_passwd_callback_userdata=u;
+ }
+
+void SSL_CTX_set_cert_verify_callback(SSL_CTX *ctx,int (*cb)(),char *arg)
+ {
+ /* now
+ * int (*cb)(X509_STORE_CTX *),
+ * but should be
+ * int (*cb)(X509_STORE_CTX *, void *arg)
+ */
ctx->app_verify_callback=cb;
- ctx->app_verify_arg=arg;
+ ctx->app_verify_arg=arg; /* never used */
}
void SSL_CTX_set_verify(SSL_CTX *ctx,int mode,int (*cb)(int, X509_STORE_CTX *))
emask|=SSL_aDSS;
}
-#ifdef SSL_ALLOW_ADH
mask|=SSL_aNULL;
emask|=SSL_aNULL;
-#endif
c->mask=mask;
c->export_mask=emask;
{
unsigned long alg,mask,kalg;
CERT *c;
- int i,export;
+ int i,is_export;
c=s->cert;
ssl_set_cert_masks(c, s->s3->tmp.new_cipher);
alg=s->s3->tmp.new_cipher->algorithms;
- export=SSL_IS_EXPORT(alg);
- mask=export?c->export_mask:c->mask;
+ is_export=SSL_C_IS_EXPORT(s->s3->tmp.new_cipher);
+ mask=is_export?c->export_mask:c->mask;
kalg=alg&(SSL_MKEY_MASK|SSL_AUTH_MASK);
if (kalg & SSL_kDHr)
if (BIO_should_read(bio))
return(SSL_ERROR_WANT_READ);
else if (BIO_should_write(bio))
+ /* This one doesn't make too much sense ... We never try
+ * to write to the rbio, and an application program where
+ * rbio and wbio are separate couldn't even know what it
+ * should wait for.
+ * However if we ever set s->rwstate incorrectly
+ * (so that we have SSL_want_read(s) instead of
+ * SSL_want_write(s)) and rbio and wbio *are* the same,
+ * this test works around that bug; so it might be safer
+ * to keep it. */
return(SSL_ERROR_WANT_WRITE);
else if (BIO_should_io_special(bio))
{
if (BIO_should_write(bio))
return(SSL_ERROR_WANT_WRITE);
else if (BIO_should_read(bio))
+ /* See above (SSL_want_read(s) with BIO_should_write(bio)) */
return(SSL_ERROR_WANT_READ);
else if (BIO_should_io_special(bio))
{
return(NULL);
}
-char *SSL_get_version(SSL *s)
+const char *SSL_get_version(SSL *s)
{
if (s->version == TLS1_VERSION)
return("TLSv1");
{
STACK_OF(X509_NAME) *sk;
X509_NAME *xn;
- SSL *ret;
+ SSL *ret;
int i;
if ((ret=SSL_new(SSL_get_SSL_CTX(s))) == NULL)
SSL_CIPHER *SSL_get_current_cipher(SSL *s)
{
- if ((s->session != NULL) && (s->session->cipher != NULL))
- return(s->session->cipher);
- return(NULL);
+ if ((s->session != NULL) && (s->session->cipher != NULL))
+ return(s->session->cipher);
+ return(NULL);
}
int ssl_init_wbio_buffer(SSL *s,int push)
if (s->bbio == s->wbio)
s->wbio=BIO_pop(s->wbio);
}
- BIO_reset(bbio);
+ (void)BIO_reset(bbio);
/* if (!BIO_set_write_buffer_size(bbio,16*1024)) */
if (!BIO_set_read_buffer_size(bbio,1))
{
return(ssl->verify_result);
}
-int SSL_get_ex_new_index(long argl,char *argp,int (*new_func)(),
- int (*dup_func)(),void (*free_func)())
- {
+int SSL_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
+ CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
+ {
ssl_meth_num++;
return(CRYPTO_get_ex_new_index(ssl_meth_num-1,
&ssl_meth,argl,argp,new_func,dup_func,free_func));
- }
+ }
int SSL_set_ex_data(SSL *s,int idx,void *arg)
{
return(CRYPTO_get_ex_data(&s->ex_data,idx));
}
-int SSL_CTX_get_ex_new_index(long argl,char *argp,int (*new_func)(),
- int (*dup_func)(),void (*free_func)())
- {
+int SSL_CTX_get_ex_new_index(long argl,void *argp,CRYPTO_EX_new *new_func,
+ CRYPTO_EX_dup *dup_func,CRYPTO_EX_free *free_func)
+ {
ssl_ctx_meth_num++;
return(CRYPTO_get_ex_new_index(ssl_ctx_meth_num-1,
&ssl_ctx_meth,argl,argp,new_func,dup_func,free_func));
- }
+ }
int SSL_CTX_set_ex_data(SSL_CTX *s,int idx,void *arg)
{
*/
#ifndef NO_RSA
-void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,int export,
+void SSL_CTX_set_tmp_rsa_callback(SSL_CTX *ctx,RSA *(*cb)(SSL *ssl,
+ int is_export,
int keylength))
- { SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,0,(char *)cb); }
-#endif
+ {
+ SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
+ }
-#ifndef NO_RSA
-void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,int export,
- int keylength))
- { SSL_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,0,(char *)cb); }
+void SSL_set_tmp_rsa_callback(SSL *ssl,RSA *(*cb)(SSL *ssl,
+ int is_export,
+ int keylength))
+ {
+ SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_RSA_CB,(void (*)())cb);
+ }
#endif
#ifdef DOXYGEN
/*!
* \brief The RSA temporary key callback function.
* \param ssl the SSL session.
- * \param export \c TRUE if the temp RSA key is for an export ciphersuite.
- * \param keylength if \c export is \c TRUE, then \c keylength is the size of
- * the required key in bits.
+ * \param is_export \c TRUE if the temp RSA key is for an export ciphersuite.
+ * \param keylength if \c is_export is \c TRUE, then \c keylength is the size
+ * of the required key in bits.
* \return the temporary RSA key.
* \sa SSL_CTX_set_tmp_rsa_callback, SSL_set_tmp_rsa_callback
*/
-RSA *cb(SSL *ssl,int export,int keylength)
+RSA *cb(SSL *ssl,int is_export,int keylength)
{}
#endif
*/
#ifndef NO_DH
-void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int export,
+void SSL_CTX_set_tmp_dh_callback(SSL_CTX *ctx,DH *(*dh)(SSL *ssl,int is_export,
int keylength))
- { SSL_CTX_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,0,(char *)dh); }
+ {
+ SSL_CTX_callback_ctrl(ctx,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
+ }
-void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int export,
- int keylength))
- { SSL_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,0,(char *)dh); }
+void SSL_set_tmp_dh_callback(SSL *ssl,DH *(*dh)(SSL *ssl,int is_export,
+ int keylength))
+ {
+ SSL_callback_ctrl(ssl,SSL_CTRL_SET_TMP_DH_CB,(void (*)())dh);
+ }
#endif
#if defined(_WINDLL) && defined(WIN16)
projects / openssl.git / blobdiff