updated auth info structures handling.

Corrected bug in DHE_RSA.

diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index cda1f4d78f14e8115f76ed179f6c4a218a710996..072802ca41c515e0c9f7ad2a943b691414d5912e 100644 (file)
--- a/lib/auth_anon.c
+++ b/lib/auth_anon.c
@@ -67,11 +67,12 @@ int _gnutls_generate_key(GNUTLS_KEY key) {
 
 int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
        MPI x, X, g, p;
-       int bits;
+       int bits, ret;
        size_t n_X, n_g, n_p;
        uint8 *data_p;
        uint8 *data_g;
        uint8 *data_X;
+       ANON_SERVER_AUTH_INFO info;
 
        bits = _gnutls_dh_get_bits( state);
 
@@ -81,18 +82,13 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
                return GNUTLS_E_MEMORY_ERROR;
        }
 
-       if ( state->gnutls_key->auth_info == NULL) {
-               state->gnutls_key->auth_info = gnutls_malloc(sizeof(ANON_SERVER_AUTH_INFO_INT));
-               if (state->gnutls_key->auth_info==NULL) return GNUTLS_E_MEMORY_ERROR;
-               state->gnutls_key->auth_info_type = GNUTLS_ANON;
-               state->gnutls_key->auth_info_size = sizeof(ANON_SERVER_AUTH_INFO_INT);
-       } else 
-               if (gnutls_auth_get_type( state) != state->gnutls_key->auth_info_type) {
-                       gnutls_assert();
-                       return GNUTLS_E_INVALID_REQUEST;
-               }                                                                                       
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_ANON, sizeof( ANON_SERVER_AUTH_INFO_INT))) < 0) {
+               gnutls_assert();
+               return ret;
+       }
 
-       ((ANON_SERVER_AUTH_INFO)state->gnutls_key->auth_info)->dh_bits = gcry_mpi_get_nbits(p);
+       info = _gnutls_get_auth_info( state);   
+       info->dh_bits = gcry_mpi_get_nbits(p);
 
        X = gnutls_calc_dh_secret(&x, g, p);
        if (X==NULL || x==NULL) {
@@ -184,8 +180,8 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
        uint8 *data_p;
        uint8 *data_g;
        uint8 *data_Y;
-       int i;
-
+       int i, ret;
+       ANON_CLIENT_AUTH_INFO info;
 
        i = 0;
        DECR_LEN( data_size, 2);
@@ -234,22 +230,13 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
        }
 
        /* set auth_info */
-       if (state->gnutls_key->auth_info==NULL)
-               state->gnutls_key->auth_info = gnutls_malloc(sizeof(ANON_CLIENT_AUTH_INFO_INT));
-       else
-               if (gnutls_auth_get_type( state) != state->gnutls_key->auth_info_type) {
-                       gnutls_assert();
-                       return GNUTLS_E_INVALID_REQUEST;
-               }                                                                                       
-
-       if (state->gnutls_key->auth_info==NULL) return GNUTLS_E_MEMORY_ERROR;
-       ((ANON_CLIENT_AUTH_INFO)state->gnutls_key->auth_info)->dh_bits = gcry_mpi_get_nbits(state->gnutls_key->client_p);
-       state->gnutls_key->auth_info_size = sizeof(ANON_CLIENT_AUTH_INFO_INT);
-       state->gnutls_key->auth_info_type = GNUTLS_ANON;
-
-       /* We should check signature in non-anonymous KX 
-        * this is anonymous however
-        */
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_ANON, sizeof( ANON_CLIENT_AUTH_INFO_INT))) < 0) {
+               gnutls_assert();
+               return ret;
+       }
+
+       info = _gnutls_get_auth_info( state);
+       info->dh_bits = gcry_mpi_get_nbits(state->gnutls_key->client_p);
 
        return 0;
 }

diff --git a/lib/auth_anon.h b/lib/auth_anon.h
index 8ce554e83e3ffd8dcb2364811b3a80e470f8e9b9..9b4a4209d02f26114cba83bcf9c0115c9ca09422 100644 (file)
--- a/lib/auth_anon.h
+++ b/lib/auth_anon.h
@@ -1,12 +1,8 @@
 /* this is not to be included by gnutls_anon.c */
 #include <gnutls_auth.h>
 
-typedef struct {
-       int dh_bits;
-} ANON_SERVER_CREDENTIALS_INT;
-
-#define GNUTLS_ANON_SERVER_CREDENTIALS ANON_SERVER_CREDENTIALS_INT*
-#define GNUTLS_ANON_CLIENT_CREDENTIALS ANON_SERVER_CREDENTIALS_INT*
+#define GNUTLS_ANON_SERVER_CREDENTIALS void*
+#define GNUTLS_ANON_CLIENT_CREDENTIALS void*
 
 typedef struct ANON_CLIENT_AUTH_INFO_INT {
        int dh_bits;

diff --git a/lib/auth_dhe_rsa.c b/lib/auth_dhe_rsa.c
index 520ac7e6f802a0c51eddb4c7784907ff2f71b5f2..697fe408a641697516ac878f49cfc85b0a2a9bc7 100644 (file)
--- a/lib/auth_dhe_rsa.c
+++ b/lib/auth_dhe_rsa.c
@@ -86,27 +86,13 @@ static int gen_dhe_rsa_server_kx(GNUTLS_STATE state, opaque ** data)
                return GNUTLS_E_MEMORY_ERROR;
        }
 
-       if (state->gnutls_key->auth_info == NULL) {
-               state->gnutls_key->auth_info =
-                   gnutls_calloc(1, sizeof(X509PKI_AUTH_INFO_INT));
-               if (state->gnutls_key->auth_info == NULL)
-                       return GNUTLS_E_MEMORY_ERROR;
-
-               state->gnutls_key->auth_info_size =
-                   sizeof(X509PKI_AUTH_INFO_INT);
-
-               info = state->gnutls_key->auth_info;
-               info->dh_bits = gcry_mpi_get_nbits(p);
-               state->gnutls_key->auth_info_type = GNUTLS_X509PKI;
-
-       } else
-           if (gnutls_auth_get_type(state) !=
-               state->gnutls_key->auth_info_type) {
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_X509PKI, sizeof( X509PKI_AUTH_INFO_INT))) < 0) {
                gnutls_assert();
-               return GNUTLS_E_INVALID_REQUEST;
+               return ret;
        }
 
-       info = state->gnutls_key->auth_info;
+       info = _gnutls_get_auth_info( state);
+       info->dh_bits = gcry_mpi_get_nbits(p);
 
        X = gnutls_calc_dh_secret(&x, g, p);
        if (X == NULL) {
@@ -248,7 +234,7 @@ static int proc_dhe_rsa_server_kx(GNUTLS_STATE state, opaque * data,
        int i, sigsize;
        gnutls_datum vparams, signature;
        int ret;
-       X509PKI_AUTH_INFO info = state->gnutls_key->auth_info;
+       X509PKI_AUTH_INFO info = _gnutls_get_auth_info( state);
        gnutls_cert peer_cert;
 
        if (info == NULL || info->ncerts==0) {
@@ -290,10 +276,7 @@ static int proc_dhe_rsa_server_kx(GNUTLS_STATE state, opaque * data,
        DECR_LEN( data_size, n_Y);
        data_Y = &data[i];
        i += n_Y;
-       if (i > data_size) {
-               gnutls_assert();
-               return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
-       }
+
        _n_Y = n_Y;
        _n_g = n_g;
        _n_p = n_p;
@@ -312,23 +295,19 @@ static int proc_dhe_rsa_server_kx(GNUTLS_STATE state, opaque * data,
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
+       info->dh_bits = gcry_mpi_get_nbits( state->gnutls_key->client_p);
 
        /* VERIFY SIGNATURE */
 
        vparams.size = n_Y + n_p + n_g + 6;
        vparams.data = data;
 
-       if (data_size - vparams.size - 2 <= 0) {        /* check if the peer sent enough data */
-               gnutls_assert();
-               return GNUTLS_E_UNEXPECTED_PACKET_LENGTH;
-       }
-
        DECR_LEN( data_size, 2);
        sigsize = READuint16(&data[vparams.size]);
 
        DECR_LEN( data_size, sigsize);
        signature.data = &data[vparams.size + 2];
-       signature.size = GMIN(data_size - vparams.size - 2, sigsize);
+       signature.size = sigsize;
 
        if ((ret =
             _gnutls_cert2gnutlsCert( &peer_cert,

diff --git a/lib/auth_srp.c b/lib/auth_srp.c
index d568657c306fd6187b1973726a0d5260f4f21b28..0275624dd1a14119807667f1e4fb79037025e2a9 100644 (file)
--- a/lib/auth_srp.c
+++ b/lib/auth_srp.c
@@ -75,24 +75,18 @@ int gen_srp_server_hello(GNUTLS_STATE state, opaque ** data)
        uint8 pwd_algo;
        GNUTLS_SRP_PWD_ENTRY *pwd_entry;
        int err;
-
-       if ( state->gnutls_key->auth_info == NULL) {
-               state->gnutls_key->auth_info = gnutls_calloc(1, sizeof(SRP_SERVER_AUTH_INFO_INT));
-               state->gnutls_key->auth_info_type = GNUTLS_SRP;
-       } else
-               if (gnutls_auth_get_type( state) != state->gnutls_key->auth_info_type) {
-                       gnutls_assert();
-                       return GNUTLS_E_INVALID_REQUEST;
-               }                                                                                       
-                                       
-       if (state->gnutls_key->auth_info == NULL) {
+       SRP_SERVER_AUTH_INFO info;
+       
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_SRP, sizeof( SRP_SERVER_AUTH_INFO_INT))) < 0) {
                gnutls_assert();
-               return GNUTLS_E_MEMORY_ERROR;
+               return ret;
        }
-       state->gnutls_key->auth_info_size = sizeof(SRP_SERVER_AUTH_INFO_INT);
+
+       info = _gnutls_get_auth_info( state);
+       username = info->username;
        
-       username = ((SRP_SERVER_AUTH_INFO)state->gnutls_key->auth_info)->username;
-       strcpy( username, state->security_parameters.extensions.srp_username);
+       strncpy( username, state->security_parameters.extensions.srp_username, MAX_SRP_USERNAME);
+       username[ MAX_SRP_USERNAME - 1] = 0;
 
        pwd_entry = _gnutls_srp_pwd_read_entry( state->gnutls_key, username, &err);
 

diff --git a/lib/auth_x509.c b/lib/auth_x509.c
index fbb17ed948673279ccb33f357f8aba0b16721698..f691ae7c3d0d49a57764da8df26b752f31f54430 100644 (file)
--- a/lib/auth_x509.c
+++ b/lib/auth_x509.c
@@ -484,33 +484,17 @@ int _gnutls_proc_x509_server_certificate(GNUTLS_STATE state, opaque * data,
        }
 
 
-       if (state->gnutls_key->auth_info == NULL) {
-               state->gnutls_key->auth_info =
-                   gnutls_calloc(1, sizeof(X509PKI_AUTH_INFO_INT));
-               if (state->gnutls_key->auth_info == NULL) {
-                       gnutls_assert();
-                       return GNUTLS_E_MEMORY_ERROR;
-               }
-               state->gnutls_key->auth_info_size =
-                   sizeof(X509PKI_AUTH_INFO_INT);
-
-               info = state->gnutls_key->auth_info;
-
-               state->gnutls_key->auth_info_type = GNUTLS_X509PKI;
-       } else
-           if (gnutls_auth_get_type(state) !=
-               state->gnutls_key->auth_info_type) {
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_X509PKI, sizeof( X509PKI_AUTH_INFO_INT))) < 0) {
                gnutls_assert();
-               return GNUTLS_E_INVALID_REQUEST;
+               return ret;
        }
 
-       info = state->gnutls_key->auth_info;
+       info = _gnutls_get_auth_info( state);
 
        DECR_LEN(dsize, 3);
        size = READuint24(p);
        p += 3;
 
-
        if (size == 0) {
                gnutls_assert();
                /* no certificate was sent */
@@ -658,19 +642,12 @@ int _gnutls_proc_x509_cert_req(GNUTLS_STATE state, opaque * data,
        }
        state->gnutls_key->certificate_requested = 1;
 
-       if (state->gnutls_key->auth_info == NULL) {
-               state->gnutls_key->auth_info =
-                   gnutls_calloc(1, sizeof(X509PKI_AUTH_INFO_INT));
-               if (state->gnutls_key->auth_info == NULL) {
-                       gnutls_assert();
-                       return GNUTLS_E_MEMORY_ERROR;
-               }
-               state->gnutls_key->auth_info_size =
-                   sizeof(X509PKI_AUTH_INFO_INT);
-
-               info = state->gnutls_key->auth_info;
+       if ( (ret=_gnutls_auth_info_set( state, GNUTLS_X509PKI, sizeof( X509PKI_AUTH_INFO_INT))) < 0) {
+               gnutls_assert();
+               return ret;
        }
-       info = state->gnutls_key->auth_info;
+
+       info = _gnutls_get_auth_info( state);
 
        DECR_LEN(dsize, 1);
        size = p[0];
@@ -767,7 +744,7 @@ int _gnutls_proc_x509_client_cert_vrfy(GNUTLS_STATE state, opaque * data,
        int dsize = data_size;
        opaque *pdata = data;
        gnutls_datum sig;
-       X509PKI_AUTH_INFO info = state->gnutls_key->auth_info;
+       X509PKI_AUTH_INFO info = _gnutls_get_auth_info( state);
        gnutls_cert peer_cert;
 
        if (info == NULL || info->ncerts == 0) {

diff --git a/lib/gnutls_algorithms.c b/lib/gnutls_algorithms.c
index ef5b26d8b8221e96ef09beafad700f6eb0fe0c31..87c3d3d9939270458cd2bdaf61a7fa88be723f22 100644 (file)
--- a/lib/gnutls_algorithms.c
+++ b/lib/gnutls_algorithms.c
@@ -206,7 +206,7 @@ typedef struct {
        MACAlgorithm mac_algorithm;
 } gnutls_cipher_suite_entry;
 
-#define GNUTLS_X509PKI_RSA_NULL_MD5 { 0x00, 0x01 }
+#define GNUTLS_RSA_NULL_MD5 { 0x00, 0x01 }
 
 #define GNUTLS_ANON_DH_3DES_EDE_CBC_SHA { 0x00, 0x1B }
 #define GNUTLS_ANON_DH_ARCFOUR_MD5 { 0x00, 0x18 }
@@ -224,27 +224,27 @@ typedef struct {
 #define GNUTLS_SRP_TWOFISH_128_CBC_SHA { 0xF6, 0x64 }
 
 /* RSA */
-#define GNUTLS_X509PKI_RSA_ARCFOUR_SHA { 0x00, 0x05 }
-#define GNUTLS_X509PKI_RSA_ARCFOUR_MD5 { 0x00, 0x04 }
-#define GNUTLS_X509PKI_RSA_3DES_EDE_CBC_SHA { 0x00, 0x0A }
-#define GNUTLS_X509PKI_RSA_DES_CBC_SHA { 0x00, 0x09 }
-#define GNUTLS_X509PKI_RSA_RIJNDAEL_128_CBC_SHA { 0x00, 0x2F }
-#define GNUTLS_X509PKI_RSA_RIJNDAEL_256_CBC_SHA { 0x00, 0x35 }
-#define GNUTLS_X509PKI_RSA_TWOFISH_128_CBC_SHA { 0xF6, 0x51 }
+#define GNUTLS_RSA_ARCFOUR_SHA { 0x00, 0x05 }
+#define GNUTLS_RSA_ARCFOUR_MD5 { 0x00, 0x04 }
+#define GNUTLS_RSA_3DES_EDE_CBC_SHA { 0x00, 0x0A }
+#define GNUTLS_RSA_DES_CBC_SHA { 0x00, 0x09 }
+#define GNUTLS_RSA_RIJNDAEL_128_CBC_SHA { 0x00, 0x2F }
+#define GNUTLS_RSA_RIJNDAEL_256_CBC_SHA { 0x00, 0x35 }
+#define GNUTLS_RSA_TWOFISH_128_CBC_SHA { 0xF6, 0x51 }
 
 /* X509PKI_DHE_DSS */
-#define GNUTLS_X509PKI_DHE_DSS_RIJNDAEL_256_CBC_SHA { 0x00, 0x38 }
-#define GNUTLS_X509PKI_DHE_DSS_RIJNDAEL_128_CBC_SHA { 0x00, 0x32 }
-#define GNUTLS_X509PKI_DHE_DSS_DES_CBC_SHA { 0x00, 0x12 }
-#define GNUTLS_X509PKI_DHE_DSS_TWOFISH_128_CBC_SHA { 0xF6, 0x54 }
-#define GNUTLS_X509PKI_DHE_DSS_3DES_EDE_CBC_SHA { 0x00, 0x13 }
+#define GNUTLS_DHE_DSS_RIJNDAEL_256_CBC_SHA { 0x00, 0x38 }
+#define GNUTLS_DHE_DSS_RIJNDAEL_128_CBC_SHA { 0x00, 0x32 }
+#define GNUTLS_DHE_DSS_DES_CBC_SHA { 0x00, 0x12 }
+#define GNUTLS_DHE_DSS_TWOFISH_128_CBC_SHA { 0xF6, 0x54 }
+#define GNUTLS_DHE_DSS_3DES_EDE_CBC_SHA { 0x00, 0x13 }
 
 /* X509PKI_DHE_RSA */
-#define GNUTLS_X509PKI_DHE_RSA_TWOFISH_128_CBC_SHA { 0xF6, 0x55 }
-#define GNUTLS_X509PKI_DHE_RSA_3DES_EDE_CBC_SHA { 0x00, 0x16 }
-#define GNUTLS_X509PKI_DHE_RSA_DES_CBC_SHA { 0x00, 0x15 }
-#define GNUTLS_X509PKI_DHE_RSA_RIJNDAEL_128_CBC_SHA { 0x00, 0x33 }
-#define GNUTLS_X509PKI_DHE_RSA_RIJNDAEL_256_CBC_SHA { 0x00, 0x39 }
+#define GNUTLS_DHE_RSA_TWOFISH_128_CBC_SHA { 0xF6, 0x55 }
+#define GNUTLS_DHE_RSA_3DES_EDE_CBC_SHA { 0x00, 0x16 }
+#define GNUTLS_DHE_RSA_DES_CBC_SHA { 0x00, 0x15 }
+#define GNUTLS_DHE_RSA_RIJNDAEL_128_CBC_SHA { 0x00, 0x33 }
+#define GNUTLS_DHE_RSA_RIJNDAEL_256_CBC_SHA { 0x00, 0x39 }
 
 static const gnutls_cipher_suite_entry cs_algorithms[] = {
        /* ANON_DH */
@@ -285,54 +285,54 @@ static const gnutls_cipher_suite_entry cs_algorithms[] = {
                                  GNUTLS_MAC_SHA),
 
        /* X509PKI_DHE_DSS */
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_DSS_TWOFISH_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_DSS_TWOFISH_128_CBC_SHA,
                                  GNUTLS_CIPHER_TWOFISH_128_CBC, GNUTLS_KX_DHE_DSS,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_DSS_3DES_EDE_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_DSS_3DES_EDE_CBC_SHA,
                                  GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_DSS,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_DSS_RIJNDAEL_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_DSS_RIJNDAEL_128_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_128_CBC, GNUTLS_KX_DHE_DSS,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_DSS_RIJNDAEL_256_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_DSS_RIJNDAEL_256_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_256_CBC, GNUTLS_KX_DHE_DSS,
                                  GNUTLS_MAC_SHA),
 
        /* X509PKI_DHE_RSA */
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_RSA_TWOFISH_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_RSA_TWOFISH_128_CBC_SHA,
                                  GNUTLS_CIPHER_TWOFISH_128_CBC, GNUTLS_KX_DHE_RSA,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_RSA_3DES_EDE_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_RSA_3DES_EDE_CBC_SHA,
                                  GNUTLS_CIPHER_3DES_CBC, GNUTLS_KX_DHE_RSA,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_RSA_RIJNDAEL_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_RSA_RIJNDAEL_128_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_128_CBC, GNUTLS_KX_DHE_RSA,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_DHE_RSA_RIJNDAEL_256_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_DHE_RSA_RIJNDAEL_256_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_256_CBC, GNUTLS_KX_DHE_RSA,
                                  GNUTLS_MAC_SHA),
 
        /* X509PKI_RSA */
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_NULL_MD5,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_NULL_MD5,
                                  GNUTLS_CIPHER_NULL,
                                  GNUTLS_KX_RSA, GNUTLS_MAC_MD5),
 
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_ARCFOUR_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_ARCFOUR_SHA,
                                  GNUTLS_CIPHER_ARCFOUR,
                                  GNUTLS_KX_RSA, GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_ARCFOUR_MD5,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_ARCFOUR_MD5,
                                  GNUTLS_CIPHER_ARCFOUR,
                                  GNUTLS_KX_RSA, GNUTLS_MAC_MD5),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_3DES_EDE_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_3DES_EDE_CBC_SHA,
                                  GNUTLS_CIPHER_3DES_CBC,
                                  GNUTLS_KX_RSA, GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_RIJNDAEL_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_RIJNDAEL_128_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_128_CBC, GNUTLS_KX_RSA,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_RIJNDAEL_256_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_RIJNDAEL_256_CBC_SHA,
                                  GNUTLS_CIPHER_RIJNDAEL_256_CBC, GNUTLS_KX_RSA,
                                  GNUTLS_MAC_SHA),
-       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_X509PKI_RSA_TWOFISH_128_CBC_SHA,
+       GNUTLS_CIPHER_SUITE_ENTRY(GNUTLS_RSA_TWOFISH_128_CBC_SHA,
                                  GNUTLS_CIPHER_TWOFISH_128_CBC, GNUTLS_KX_RSA,
                                  GNUTLS_MAC_SHA),
 

diff --git a/lib/gnutls_anon_cred.c b/lib/gnutls_anon_cred.c
index 189b2036891f6612053e286b2bcf0e97064b2c9b..379d821b23e5155c91c1cfd94027f8879011a6a5 100644 (file)
--- a/lib/gnutls_anon_cred.c
+++ b/lib/gnutls_anon_cred.c
@@ -26,7 +26,7 @@
 #include "gnutls_num.h"
 #include "gnutls_gcry.h"
 
-const static int anon_tmp;
+static int anon_tmp;
 
 /**
   * gnutls_anon_free_server_sc - Used to free an allocated GNUTLS_ANON_SERVER_CREDENTIALS structure

diff --git a/lib/gnutls_auth.c b/lib/gnutls_auth.c
index f0791161b42e4716bec3ff0d48354c7aa3ffa848..1b11d8be0b24e2428198c99cf44cd0cf6cd16c50 100644 (file)
--- a/lib/gnutls_auth.c
+++ b/lib/gnutls_auth.c
@@ -233,3 +233,26 @@ void _gnutls_free_auth_info( GNUTLS_STATE state) {
 
 }
 
+int _gnutls_auth_info_set( GNUTLS_STATE state, CredType type, int size) {
+       if ( state->gnutls_key->auth_info == NULL) {
+               state->gnutls_key->auth_info = gnutls_calloc( 1, size);
+               if (state->gnutls_key->auth_info == NULL) {
+                       gnutls_assert();
+                       return GNUTLS_E_MEMORY_ERROR;
+               }
+               state->gnutls_key->auth_info_type = type;
+               state->gnutls_key->auth_info_size = size;
+       } else
+               /* If the credentials for the current authentication scheme,
+                * are not the one we want to set, then it's an error.
+                * This may happen if a rehandshake is performed an the
+                * ciphersuite which is negotiated has different authentication
+                * schema.
+                */
+               if ( gnutls_auth_get_type( state) != state->gnutls_key->auth_info_type) {
+                       gnutls_assert();
+                       return GNUTLS_E_INVALID_REQUEST;
+               }
+
+       return 0;
+}

diff --git a/lib/gnutls_auth_int.h b/lib/gnutls_auth_int.h
index 2e46c54d064ed6af32184f41eaf590611cadcd2d..a850bcac3e312f9502ac664f264c5f2be048aa92 100644 (file)
--- a/lib/gnutls_auth_int.h
+++ b/lib/gnutls_auth_int.h
@@ -5,3 +5,4 @@ const void *_gnutls_get_kx_cred( GNUTLS_KEY key, KXAlgorithm algo, int *err);
 int _gnutls_generate_key(GNUTLS_KEY key);
 CredType gnutls_auth_get_type( GNUTLS_STATE state);
 void* _gnutls_get_auth_info( GNUTLS_STATE state);
+int _gnutls_auth_info_set( GNUTLS_STATE state, CredType type, int size);

diff --git a/lib/gnutls_int.h b/lib/gnutls_int.h
index d1d8e58abea2038fc2f4302dbe5880831bb7308e..0977b63306466aac8ee87b88ec81186f23603072 100644 (file)
--- a/lib/gnutls_int.h
+++ b/lib/gnutls_int.h
@@ -26,14 +26,14 @@
 
 /*
 #define IO_DEBUG 3 // define this to check non blocking behaviour 
-#define BUFFERS_DEBUG
 #define HARD_DEBUG
 #define WRITE_DEBUG
 #define READ_DEBUG
+#define RECORD_DEBUG*/
+#define BUFFERS_DEBUG
 #define HANDSHAKE_DEBUG // Prints some information on handshake 
-#define RECORD_DEBUG
 #define DEBUG
-*/
+
 
 /* It might be a good idea to replace int with void*
  * here.