several cleanups

diff --git a/lib/auth_dhe_rsa.c b/lib/auth_dhe_rsa.c
index 68777f5e2cc2473691d70649811d73109da50034..4777d7a2ff0ceff7cc74f134d0e6da432efe47ee 100644 (file)
--- a/lib/auth_dhe_rsa.c
+++ b/lib/auth_dhe_rsa.c
@@ -148,26 +148,13 @@ static int gen_dhe_rsa_server_kx(GNUTLS_STATE state, opaque ** data)
 
        /* Generate the signature. */
 
-       /* If our certificate supports signing
-        */
-       if (apr_cert_list != NULL)
-               if (apr_cert_list[0].keyUsage != 0)
-                       if (!
-                           (apr_cert_list[0].
-                            keyUsage & X509KEY_DIGITAL_SIGNATURE)) {
-                               gnutls_assert();
-                               gnutls_free( *data);
-                               return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
-                       }
-
-
        ddata.data = *data;
        ddata.size = data_size;
 
        if (apr_pkey != NULL) {
                if ((ret =
                     _gnutls_generate_sig_params(
-                       state, apr_pkey, &ddata, &signature)) < 0) {
+                       state, &apr_cert_list[0], apr_pkey, &ddata, &signature)) < 0) {
                        gnutls_assert();
                        gnutls_free( *data);
                        return ret;
@@ -313,12 +300,6 @@ static int proc_dhe_rsa_server_kx(GNUTLS_STATE state, opaque * data,
        signature.data = &data[vparams.size+2];
        signature.size = GMIN(data_size-vparams.size-2, sigsize);       
 
-       if (state->gnutls_internals.peer_cert.version == 0) { /* this is the only way to check
-                                                              * if it is initialized
-                                                              */
-               gnutls_assert();
-               return GNUTLS_E_X509_CERTIFICATE_ERROR;
-       }
        ret = _gnutls_verify_sig_params( state, &state->gnutls_internals.peer_cert, &vparams, &signature);
        if (ret<0) {
                gnutls_assert();

diff --git a/lib/auth_x509.c b/lib/auth_x509.c
index f34268f22c1f4818c4968bbb6a272d81647341ad..f6bad788a1134cc5c22ea6873ce17c84da837ed6 100644 (file)
--- a/lib/auth_x509.c
+++ b/lib/auth_x509.c
@@ -507,6 +507,7 @@ int _gnutls_gen_x509_server_certificate(GNUTLS_STATE state, opaque ** data)
        return pdatasize;
 }
 
+
 #define CLEAR_CERTS for(x=0;x<peer_certificate_list_size;x++) gnutls_free_cert(peer_certificate_list[x])
 int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data, int data_size)
 {
@@ -639,15 +640,12 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data, int
 
        _gnutls_copy_x509_client_auth_info(info, &peer_certificate_list[0], verify);
 
-       /* This works for the client
-        */
-       if ( peer_certificate_list[0].keyUsage != 0)
-               if ( !(peer_certificate_list[0].keyUsage & X509KEY_KEY_ENCIPHERMENT)) {
-                       gnutls_assert();
-                       CLEAR_CERTS;
-                       gnutls_free(peer_certificate_list);
-                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
-               }
+       if ( (ret=_gnutls_check_x509_key_usage( &peer_certificate_list[0], gnutls_get_current_kx( state))) < 0) {
+               gnutls_assert();
+               CLEAR_CERTS;
+               gnutls_free(peer_certificate_list);
+               return ret;
+       }
 
        CLEAR_CERTS;
        gnutls_free(peer_certificate_list);
@@ -656,7 +654,20 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data, int
 }
 
 
+#ifdef DEBUG
+# warning CHECK FOR DSS
+#endif
+
 #define RSA_SIGN 1
+int _gnutls_check_supported_sign_algo( uint8 algo) {
+       switch(algo) {
+               case RSA_SIGN:
+                       return 0;
+       }
+       
+       return -1;
+}
+
 int _gnutls_proc_x509_cert_req(GNUTLS_STATE state, opaque * data, int data_size)
 {
        int size, ret;
@@ -697,7 +708,7 @@ int _gnutls_proc_x509_cert_req(GNUTLS_STATE state, opaque * data, int data_size)
        found = 0;
        for (i = 0; i < size; i++, p++) {
                DECR_LEN(dsize, 1);
-               if (*p == RSA_SIGN)
+               if ( _gnutls_check_supported_sign_algo(*p)==0)
                        found = 1;
        }
 
@@ -741,17 +752,8 @@ int _gnutls_gen_x509_client_cert_vrfy(GNUTLS_STATE state, opaque ** data)
                return ret;
        }
        
-       /* If our certificate supports signing
-        */
-       if ( apr_cert_list != NULL)
-          if ( apr_cert_list[0].keyUsage != 0)
-               if ( !(apr_cert_list[0].keyUsage & X509KEY_DIGITAL_SIGNATURE)) {
-                       gnutls_assert();
-                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
-               }
-       
        if (apr_pkey != NULL) {
-               if ( (ret=_gnutls_generate_sig_from_hdata( state, apr_pkey, &signature)) < 0) {
+               if ( (ret=_gnutls_generate_sig_from_hdata( state, &apr_cert_list[0], apr_pkey, &signature)) < 0) {
                        gnutls_assert();
                        return ret;
                }
@@ -793,7 +795,7 @@ gnutls_datum sig;
 
        sig.data = pdata;
        sig.size = size;
-       
+
        if ( (ret=_gnutls_verify_sig_hdata( state, &state->gnutls_internals.peer_cert, &sig, data_size+HANDSHAKE_HEADER_SIZE))<0) {
                gnutls_assert();
                return ret;

diff --git a/lib/gnutls.h.in b/lib/gnutls.h.in
index 5aba9aa75090309eb62a2dd084a72b67bc22cace..f496a1465f2dd88f8032ac6859ffe469e7c33221 100644 (file)
--- a/lib/gnutls.h.in
+++ b/lib/gnutls.h.in
@@ -136,6 +136,8 @@ int gnutls_set_cache_expiration( GNUTLS_STATE state, int seconds);
 int gnutls_set_db_name( GNUTLS_STATE state, char* filename);   
 int gnutls_clean_db( GNUTLS_STATE state);
 
+void gnutls_set_max_handshake_data_buffer_size( GNUTLS_STATE state, int max);
+
 /* returns libgnutls version */
 const char* gnutls_check_version();
 

diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index a044f316fc97a4d1afe8267db6bc5ad1000330f7..f5a7d79cfc569197dde232b645f56f91d829b542 100644 (file)
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -377,6 +377,11 @@ int gnutls_insertHashDataBuffer( GNUTLS_STATE state, char *data, int length)
        old_buffer = state->gnutls_internals.hash_buffer.size;
 
        state->gnutls_internals.hash_buffer.size += length;
+       if (state->gnutls_internals.max_handshake_data_buffer_size > 0 && state->gnutls_internals.hash_buffer.size > state->gnutls_internals.max_handshake_data_buffer_size) {
+               gnutls_assert();
+               return GNUTLS_E_MEMORY_ERROR;
+       }
+
 #ifdef BUFFERS_DEBUG
        _gnutls_log( "HASH BUFFER: Inserted %d bytes of Data\n", length);
 #endif

diff --git a/lib/gnutls_cert.c b/lib/gnutls_cert.c
index dac06a48ea44619d9b2b7585fdcdfd5bc4389da2..50a24b238d383bf930a7c490d1db7466f93622ac 100644 (file)
--- a/lib/gnutls_cert.c
+++ b/lib/gnutls_cert.c
@@ -919,9 +919,9 @@ int _gnutls_cert2gnutlsCert(gnutls_cert * gCert, gnutls_datum derCert)
 }
 
 /* Returns 0 if it's ok to use the KXAlgorithm with this cert
- * (using KeyUsage field). 1 otherwise.
+ * (using KeyUsage field). 
  */
-static int _gnutls_check_x509_key_usage(gnutls_cert * cert,
+int _gnutls_check_x509_key_usage(gnutls_cert * cert,
                                        KXAlgorithm alg)
 {
        if (_gnutls_map_kx_get_cred(alg) == GNUTLS_X509PKI) {
@@ -931,7 +931,7 @@ static int _gnutls_check_x509_key_usage(gnutls_cert * cert,
                                if (!
                                    (cert->
                                     keyUsage & X509KEY_KEY_ENCIPHERMENT))
-                                       return 1;
+                                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
                                else
                                        return 0;
                        }
@@ -941,13 +941,14 @@ static int _gnutls_check_x509_key_usage(gnutls_cert * cert,
                                if (!
                                    (cert->
                                     keyUsage & X509KEY_DIGITAL_SIGNATURE))
-                                       return 1;
+                                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
                                else
                                        return 0;
                        }
                        return 0;
                default:
-                       return 1;
+                       gnutls_assert();
+                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
                }
        }
        return 0;

diff --git a/lib/gnutls_cert.h b/lib/gnutls_cert.h
index 0d7d6aaf903c3760723be6f03bc0a8a2af590512..2765d11229412b09b438a213bbccd6d4325ac4e8 100644 (file)
--- a/lib/gnutls_cert.h
+++ b/lib/gnutls_cert.h
@@ -58,5 +58,6 @@ int _gnutls_find_cert_list_index(gnutls_cert ** cert_list,
 void _gnutls_int2str(int k, char* data);
 int _gnutls_get_name_type( node_asn *rasn, char *root, gnutls_DN * dn);
 void gnutls_free_cert(gnutls_cert cert);
+int _gnutls_check_x509_key_usage(gnutls_cert * cert, KXAlgorithm alg);
 
 #endif

diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index 49445002f64c7d75a058459c1d5c0878aad01683..bfbe5b505ab8116f2aefacb7bbdd70205c242cd6 100644 (file)
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -1821,3 +1821,19 @@ int _gnutls_remove_unwanted_ciphersuites(GNUTLS_STATE state,
        return ret;
 
 }
+
+/**
+  * gnutls_set_max_handshake_data_buffer_size - This function will set the maximum size of handshake message sequence
+  * @state: is a a &GNUTLS_STATE structure.
+  * @max: is the maximum number.
+  *
+  * This function will set the maximum size of the handshake message sequence.
+  * Since the handshake messages are kept into memory until the handshake is successful
+  * this function allows you to set the maximum number of bytes that will be kept.
+  * The default value is 128kb which is large enough. Set this to 0 if you do not want
+  * to set an upper limit.
+  *
+  **/
+void gnutls_set_max_handshake_data_buffer_size( GNUTLS_STATE state, int max) {
+       state->gnutls_internals.max_handshake_data_buffer_size = max;
+}

diff --git a/lib/gnutls_handshake.h b/lib/gnutls_handshake.h
index 9acae2b3fb9326d0eb7afdcc995a7b1305c7fabd..be08e0a35e76fbde10513ae52c4912b85885e6b9 100644 (file)
--- a/lib/gnutls_handshake.h
+++ b/lib/gnutls_handshake.h
@@ -34,6 +34,7 @@ void _gnutls_set_server_random( GNUTLS_STATE state, uint8* random);
 void _gnutls_set_client_random( GNUTLS_STATE state, uint8* random);
 int _gnutls_create_random( opaque* dst);
 int _gnutls_remove_unwanted_ciphersuites( GNUTLS_STATE state, GNUTLS_CipherSuite ** cipherSuites, int numCipherSuites);
+void gnutls_set_max_handshake_data_buffer_size( GNUTLS_STATE state, int max);
 
 #define set_adv_version( state, major, minor) \
        state->gnutls_internals.adv_version_major = data[pos]; \

diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index b3c534ab952a82d6b7ebf0b77c1eb8e7c9be9137..f7fd11e351abe1f69464dbb63a17c08819b01007 100644 (file)
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -41,6 +41,11 @@
 #define MAX24 16777215
 #define MAX16 65535
 
+/* The sequence of handshake messages should not
+ * be larger than this value.
+ */
+#define MAX_HANDSHAKE_DATA_BUFFER_SIZE 128*1024
+
 #define TLS_RANDOM_SIZE 32
 #define TLS_MAX_SESSION_ID_SIZE 32
 #define TLS_MASTER_SIZE 48
@@ -376,6 +381,7 @@ typedef struct {
         */
        int                             (*x509_client_cert_callback)(void*,void*,int, void*, int);
        gnutls_cert                     peer_cert;
+       int                             max_handshake_data_buffer_size;
 } GNUTLS_INTERNALS;
 
 struct GNUTLS_STATE_INT {

diff --git a/lib/gnutls_record.c b/lib/gnutls_record.c
index b1582e4a30ed4bfe72d345c30d539b0a9f781d70..fd5f1688afb7621c8586497c000e03d8b43241d6 100644 (file)
--- a/lib/gnutls_record.c
+++ b/lib/gnutls_record.c
@@ -103,6 +103,8 @@ int gnutls_init(GNUTLS_STATE * state, ConnectionEnd con_end)
 
        gnutls_set_lowat((*state), DEFAULT_LOWAT); /* the default for tcp */
 
+       gnutls_set_max_handshake_data_buffer_size( (*state), MAX_HANDSHAKE_DATA_BUFFER_SIZE);
+
        /* everything else not initialized here is initialized
         * as NULL or 0. This is why calloc is used.
         */

diff --git a/lib/gnutls_sig.c b/lib/gnutls_sig.c
index 9a7ee522d0cac3cc87d10fe5d97350111a0f98c5..fbd51b3600d944a4c9b7dcdd917b371e391f4917 100644 (file)
--- a/lib/gnutls_sig.c
+++ b/lib/gnutls_sig.c
@@ -39,7 +39,7 @@
 /* Generates a signature of all the previous sended packets in the 
  * handshake procedure.
  */
-int _gnutls_generate_sig_from_hdata( GNUTLS_STATE state, gnutls_private_key *pkey, gnutls_datum *signature) {
+int _gnutls_generate_sig_from_hdata( GNUTLS_STATE state, gnutls_cert* cert, gnutls_private_key *pkey, gnutls_datum *signature) {
 gnutls_datum data;
 int size = gnutls_getHashDataBufferSize( state);
 int ret;
@@ -53,7 +53,7 @@ int ret;
                        
        gnutls_readHashDataFromBuffer( state, data.data, data.size);
 
-       ret = _gnutls_pkcs1_rsa_generate_sig( pkey, &data, signature);
+       ret = _gnutls_pkcs1_rsa_generate_sig( cert, pkey, &data, signature);
        gnutls_free_datum( &data);
        if (ret < 0) {
                gnutls_assert();
@@ -67,7 +67,7 @@ int ret;
 /* Generates a signature of all the random data and the parameters.
  * Used in DHE_* ciphersuites.
  */
-int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_private_key *pkey, gnutls_datum* params, gnutls_datum *signature) 
+int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_cert* cert, gnutls_private_key *pkey, gnutls_datum* params, gnutls_datum *signature) 
 {
        gnutls_datum sdata;
        int size = 2*TLS_RANDOM_SIZE; 
@@ -84,7 +84,7 @@ int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_private_key *pkey, g
        memcpy( &sdata.data[TLS_RANDOM_SIZE], state->security_parameters.server_random, TLS_RANDOM_SIZE);
        memcpy( &sdata.data[2*TLS_RANDOM_SIZE], params->data, params->size);
 
-       ret = _gnutls_pkcs1_rsa_generate_sig( pkey, &sdata, signature);
+       ret = _gnutls_pkcs1_rsa_generate_sig( cert, pkey, &sdata, signature);
 
        gnutls_free_datum( &sdata);
        if (ret < 0) {
@@ -98,14 +98,26 @@ int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_private_key *pkey, g
 
 
 /* This will create a PKCS1 signature, as defined in the TLS protocol.
+ * Cert is the certificate of the corresponding private key. It is only checked if
+ * it supports signing.
  */
-int _gnutls_pkcs1_rsa_generate_sig( gnutls_private_key *pkey, const gnutls_datum *data, gnutls_datum *signature) 
+int _gnutls_pkcs1_rsa_generate_sig( gnutls_cert* cert, gnutls_private_key *pkey, const gnutls_datum *data, gnutls_datum *signature) 
 {
 int ret;
 opaque digest[20+16];
 gnutls_datum tmpdata;
 GNUTLS_HASH_HANDLE td;
 
+       /* If our certificate supports signing
+        */
+
+       if ( cert != NULL)
+          if ( cert->keyUsage != 0)
+               if ( !(cert->keyUsage & X509KEY_DIGITAL_SIGNATURE)) {
+                       gnutls_assert();
+                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
+               }
+
        switch(pkey->pk_algorithm) {
                case GNUTLS_PK_RSA:
                        
@@ -152,6 +164,22 @@ int _gnutls_pkcs1_rsa_verify_sig( gnutls_cert *cert, const gnutls_datum *data, g
        opaque digest[20+16];
        GNUTLS_HASH_HANDLE td;
 
+       if (cert->version == 0 || cert==NULL) {                /* this is the only way to check
+                                                              * if it is initialized
+                                                              */
+               gnutls_assert();
+               return GNUTLS_E_X509_CERTIFICATE_ERROR;
+       }
+
+       /* If the certificate supports signing continue.
+        */
+       if ( cert != NULL)
+          if ( cert->keyUsage != 0)
+               if ( !(cert->keyUsage & X509KEY_DIGITAL_SIGNATURE)) {
+                       gnutls_assert();
+                       return GNUTLS_E_X509_KEY_USAGE_VIOLATION;
+               }
+
        switch(cert->subject_pk_algorithm) {
                case GNUTLS_PK_RSA:
                        

diff --git a/lib/gnutls_sig.h b/lib/gnutls_sig.h
index bb311c60d37a5c351c6e252c54a430221c253aa1..447908284cfedfa9c427a304a1eb5593febb679d 100644 (file)
--- a/lib/gnutls_sig.h
+++ b/lib/gnutls_sig.h
@@ -3,9 +3,9 @@
 # include <auth_x509.h>
 
 CertificateStatus gnutls_x509_verify_signature(gnutls_cert* cert, gnutls_cert* issuer);
-int _gnutls_pkcs1_rsa_generate_sig( gnutls_private_key *pkey, const gnutls_datum *data, gnutls_datum *signature);
-int _gnutls_generate_sig_from_hdata( GNUTLS_STATE state, gnutls_private_key *pkey, gnutls_datum *signature);
-int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_private_key *pkey, gnutls_datum* params, gnutls_datum *signature);
+int _gnutls_pkcs1_rsa_generate_sig( gnutls_cert*, gnutls_private_key *pkey, const gnutls_datum *data, gnutls_datum *signature);
+int _gnutls_generate_sig_from_hdata( GNUTLS_STATE state, gnutls_cert* cert, gnutls_private_key *pkey, gnutls_datum *signature);
+int _gnutls_generate_sig_params( GNUTLS_STATE state, gnutls_cert* cert, gnutls_private_key *pkey, gnutls_datum* params, gnutls_datum *signature);
 int _gnutls_verify_sig_hdata( GNUTLS_STATE state, gnutls_cert *cert, gnutls_datum* signature, int ubuffer_size);
 int _gnutls_verify_sig_params( GNUTLS_STATE state, gnutls_cert *cert, const gnutls_datum* params, gnutls_datum* signature);