Small bugfixes to the KSSL implementation.

[openssl.git] / ssl / s2_srvr.c

diff --git a/ssl/s2_srvr.c b/ssl/s2_srvr.c
index 56da65195e7e72b84c10a9d47141c55dbeede9ff..62859a2d950e2b7c2dccc67d3f1d786c714cc4ff 100644 (file)
--- a/ssl/s2_srvr.c
+++ b/ssl/s2_srvr.c
@@ -116,6 +116,7 @@
 #include <openssl/rand.h>
 #include <openssl/objects.h>
 #include <openssl/evp.h>
+#include "cryptlib.h"
 
 static SSL_METHOD *ssl2_get_server_method(int ver);
 static int get_client_master_key(SSL *s);
@@ -144,11 +145,18 @@ SSL_METHOD *SSLv2_server_method(void)
 
        if (init)
                {
-               memcpy((char *)&SSLv2_server_data,(char *)sslv2_base_method(),
-                       sizeof(SSL_METHOD));
-               SSLv2_server_data.ssl_accept=ssl2_accept;
-               SSLv2_server_data.get_ssl_method=ssl2_get_server_method;
-               init=0;
+               CRYPTO_w_lock(CRYPTO_LOCK_SSL_METHOD);
+
+               if (init)
+                       {
+                       memcpy((char *)&SSLv2_server_data,(char *)sslv2_base_method(),
+                               sizeof(SSL_METHOD));
+                       SSLv2_server_data.ssl_accept=ssl2_accept;
+                       SSLv2_server_data.get_ssl_method=ssl2_get_server_method;
+                       init=0;
+                       }
+
+               CRYPTO_w_unlock(CRYPTO_LOCK_SSL_METHOD);
                }
        return(&SSLv2_server_data);
        }
@@ -398,8 +406,7 @@ static int get_client_master_key(SSL *s)
                                SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_READ_WRONG_PACKET_TYPE);
                                }
                        else
-                               SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,
-                                       SSL_R_PEER_ERROR);
+                               SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, SSL_R_PEER_ERROR);
                        return(-1);
                        }
 
@@ -407,8 +414,7 @@ static int get_client_master_key(SSL *s)
                if (cp == NULL)
                        {
                        ssl2_return_error(s,SSL2_PE_NO_CIPHER);
-                       SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,
-                               SSL_R_NO_CIPHER_MATCH);
+                       SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, SSL_R_NO_CIPHER_MATCH);
                        return(-1);
                        }
                s->session->cipher= cp;
@@ -417,15 +423,28 @@ static int get_client_master_key(SSL *s)
                n2s(p,i); s->s2->tmp.clear=i;
                n2s(p,i); s->s2->tmp.enc=i;
                n2s(p,i); s->session->key_arg_length=i;
+               if(s->session->key_arg_length > SSL_MAX_KEY_ARG_LENGTH)
+                       {
+                       ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
+                       SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, SSL_R_KEY_ARG_TOO_LONG);
+                       return -1;
+                       }
                s->state=SSL2_ST_GET_CLIENT_MASTER_KEY_B;
                }
 
        /* SSL2_ST_GET_CLIENT_MASTER_KEY_B */
        p=(unsigned char *)s->init_buf->data;
+       if (s->init_buf->length < SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)
+               {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
+               SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
+               return -1;
+               }
        keya=s->session->key_arg_length;
        len = 10 + (unsigned long)s->s2->tmp.clear + (unsigned long)s->s2->tmp.enc + (unsigned long)keya;
        if (len > SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)
                {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_MESSAGE_TOO_LONG);
                return -1;
                }
@@ -504,6 +523,13 @@ static int get_client_master_key(SSL *s)
 #endif
 
        if (is_export) i+=s->s2->tmp.clear;
+
+       if (i > SSL_MAX_MASTER_KEY_LENGTH)
+               {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
+               SSLerr(SSL_F_GET_CLIENT_MASTER_KEY, ERR_R_INTERNAL_ERROR);
+               return -1;
+               }
        s->session->master_key_length=i;
        memcpy(s->session->master_key,p,(unsigned int)i);
        return(1);
@@ -554,6 +580,7 @@ static int get_client_hello(SSL *s)
                if (    (i < SSL2_MIN_CHALLENGE_LENGTH) ||
                        (i > SSL2_MAX_CHALLENGE_LENGTH))
                        {
+                       ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                        SSLerr(SSL_F_GET_CLIENT_HELLO,SSL_R_INVALID_CHALLENGE_LENGTH);
                        return(-1);
                        }
@@ -565,6 +592,7 @@ static int get_client_hello(SSL *s)
        len = 9 + (unsigned long)s->s2->tmp.cipher_spec_length + (unsigned long)s->s2->challenge_length + (unsigned long)s->s2->tmp.session_id_length;
        if (len > SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)
                {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                SSLerr(SSL_F_GET_CLIENT_HELLO,SSL_R_MESSAGE_TOO_LONG);
                return -1;
                }
@@ -670,6 +698,12 @@ static int get_client_hello(SSL *s)
        p+=s->s2->tmp.session_id_length;
 
        /* challenge */
+       if (s->s2->challenge_length > sizeof s->s2->challenge)
+               {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
+               SSLerr(SSL_F_GET_CLIENT_HELLO, ERR_R_INTERNAL_ERROR);
+               return -1;
+               }
        memcpy(s->s2->challenge,p,(unsigned int)s->s2->challenge_length);
        return(1);
 mem_err:
@@ -826,6 +860,12 @@ static int get_client_finished(SSL *s)
                }
 
        /* SSL2_ST_GET_CLIENT_FINISHED_B */
+       if (s->s2->conn_id_length > sizeof s->s2->conn_id)
+               {
+               ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
+               SSLerr(SSL_F_GET_CLIENT_FINISHED, ERR_R_INTERNAL_ERROR);
+               return -1;
+               }
        len = 1 + (unsigned long)s->s2->conn_id_length;
        n = (int)len - s->init_num;
        i = ssl2_read(s,(char *)&(p[s->init_num]),n);
@@ -836,7 +876,7 @@ static int get_client_finished(SSL *s)
        if (s->msg_callback)
                s->msg_callback(0, s->version, 0, p, len, s, s->msg_callback_arg); /* CLIENT-FINISHED */
        p += 1;
-       if (memcmp(p,s->s2->conn_id,(unsigned int)s->s2->conn_id_length) != 0)
+       if (memcmp(p,s->s2->conn_id,s->s2->conn_id_length) != 0)
                {
                ssl2_return_error(s,SSL2_PE_UNDEFINED_ERROR);
                SSLerr(SSL_F_GET_CLIENT_FINISHED,SSL_R_CONNECTION_ID_IS_DIFFERENT);
@@ -853,6 +893,11 @@ static int server_verify(SSL *s)
                {
                p=(unsigned char *)s->init_buf->data;
                *(p++)=SSL2_MT_SERVER_VERIFY;
+               if (s->s2->challenge_length > sizeof s->s2->challenge)
+                       {
+                       SSLerr(SSL_F_SERVER_VERIFY, ERR_R_INTERNAL_ERROR);
+                       return -1;
+                       }
                memcpy(p,s->s2->challenge,(unsigned int)s->s2->challenge_length);
                /* p+=s->s2->challenge_length; */
 
@@ -872,8 +917,12 @@ static int server_finish(SSL *s)
                p=(unsigned char *)s->init_buf->data;
                *(p++)=SSL2_MT_SERVER_FINISHED;
 
-               memcpy(p,s->session->session_id,
-                       (unsigned int)s->session->session_id_length);
+               if (s->session->session_id_length > sizeof s->session->session_id)
+                       {
+                       SSLerr(SSL_F_SERVER_FINISH, ERR_R_INTERNAL_ERROR);
+                       return -1;
+                       }
+               memcpy(p,s->session->session_id, (unsigned int)s->session->session_id_length);
                /* p+=s->session->session_id_length; */
 
                s->state=SSL2_ST_SEND_SERVER_FINISHED_B;
@@ -990,7 +1039,7 @@ static int request_certificate(SSL *s)
        len = 6 + (unsigned long)s->s2->tmp.clen + (unsigned long)s->s2->tmp.rlen;
        if (len > SSL2_MAX_RECORD_LENGTH_3_BYTE_HEADER)
                {
-               SSLerr(SSL_F_GET_CLIENT_MASTER_KEY,SSL_R_MESSAGE_TOO_LONG);
+               SSLerr(SSL_F_REQUEST_CERTIFICATE,SSL_R_MESSAGE_TOO_LONG);
                goto end;
                }
        j = (int)len - s->init_num;
@@ -1027,7 +1076,7 @@ static int request_certificate(SSL *s)
                EVP_MD_CTX_init(&ctx);
                EVP_VerifyInit_ex(&ctx,s->ctx->rsa_md5, NULL);
                EVP_VerifyUpdate(&ctx,s->s2->key_material,
-                       (unsigned int)s->s2->key_material_length);
+                                s->s2->key_material_length);
                EVP_VerifyUpdate(&ctx,ccd,SSL2_MIN_CERT_CHALLENGE_LENGTH);
 
                i=i2d_X509(s->cert->pkeys[SSL_PKEY_RSA_ENC].x509,NULL);