From: Nikos Mavrogiannopoulos <nmav@gnutls.org>
Date: Sat, 19 Jan 2002 20:09:23 +0000 (+0000)
Subject: updated auth info structures handling.
X-Git-Tag: gnutls_0_3_90~211
X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=b7180760dd3ca48fa6a4c60a0239ceec1b4e4102;p=thirdparty%2Fgnutls.git

updated auth info structures handling.
Corrected bug in DHE_RSA.
---

diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index cda1f4d78f..072802ca41 100644
--- 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 8ce554e83e..9b4a4209d0 100644
--- 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 520ac7e6f8..697fe408a6 100644
--- 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 d568657c30..0275624dd1 100644
--- 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 fbb17ed948..f691ae7c3d 100644
--- 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 ef5b26d8b8..87c3d3d993 100644
--- 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 189b203689..379d821b23 100644
--- 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 f0791161b4..1b11d8be0b 100644
--- 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 2e46c54d06..a850bcac3e 100644
--- 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 d1d8e58abe..0977b63306 100644
--- 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.