several checks for failed allocations and other fixes

10 files changed, 218 insertions, 31 deletions

diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index d06a1a0090..909d665d58 100644
--- a/lib/auth_anon.c
+++ b/lib/auth_anon.c
@@ -95,11 +95,17 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
 	state->gnutls_key->auth_info_size = sizeof(ANON_SERVER_AUTH_INFO_INT);
 
 	X = gnutls_calc_dh_secret(&x, g, p);
+	if (X==NULL) 
+		return GNUTLS_E_MEMORY_ERROR;
+
 	state->gnutls_key->dh_secret = x;
 	gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_g, g);
 	gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_p, p);
 	gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_X, X);
 	(*data) = gnutls_malloc(n_g + n_p + n_X + 6);
+	if (*data==NULL) {
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 	data_p = &(*data)[0];
 	gcry_mpi_print(GCRYMPI_FMT_USG, &data_p[2], &n_p, p);
 	_gnutls_mpi_release(&p);
@@ -128,9 +134,14 @@ int ret;
 
 	X =  gnutls_calc_dh_secret(&x, state->gnutls_key->client_g,
 		   state->gnutls_key->client_p);
-		   
+
+	if (X==NULL)
+		return GNUTLS_E_MEMORY_ERROR;
+				   
 	gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_X, X);
 	(*data) = gnutls_malloc(n_X + 2);
+	if (*data==NULL)
+		return GNUTLS_E_MEMORY_ERROR;
 	
 	gcry_mpi_print(GCRYMPI_FMT_USG, &(*data)[2], &n_X, X);
 	(*data)[0] = 1;	/* extern - explicit since we do not have
@@ -141,6 +152,8 @@ int ret;
 	
 	/* calculate the key after calculating the message */
 	state->gnutls_key->KEY = gnutls_calc_dh_key(state->gnutls_key->client_Y, x, state->gnutls_key->client_p);
+	if (state->gnutls_key->KEY==NULL)
+		return GNUTLS_E_MEMORY_ERROR;
 
 	/* THESE SHOULD BE DISCARDED */
 	_gnutls_mpi_release(&state->gnutls_key->client_Y);
@@ -267,7 +280,9 @@ int proc_anon_client_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 	}
 	
 	state->gnutls_key->KEY = gnutls_calc_dh_key( state->gnutls_key->client_Y, state->gnutls_key->dh_secret, p);
-
+	if (state->gnutls_key->KEY==NULL)
+		return GNUTLS_E_MEMORY_ERROR;
+	
 	_gnutls_mpi_release(&state->gnutls_key->client_Y);
 	_gnutls_mpi_release(&state->gnutls_key->dh_secret);
 	_gnutls_mpi_release(&p);
diff --git a/lib/auth_srp.c b/lib/auth_srp.c
index 3cb0160a22..11cd3cef95 100644
--- a/lib/auth_srp.c
+++ b/lib/auth_srp.c
@@ -180,6 +180,10 @@ int gen_srp_server_kx2(GNUTLS_STATE state, opaque ** data)
 	
 	/* calculate:  B = (v + g^b) % N */
 	B = _gnutls_calc_srp_B( &_b, G, N, V);
+	if (B==NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
 	if (gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_b, B)!=0)
 		return GNUTLS_E_MPI_PRINT_FAILED;
@@ -199,15 +203,25 @@ int gen_srp_server_kx2(GNUTLS_STATE state, opaque ** data)
 
 	/* calculate u */
 	state->gnutls_key->u = _gnutls_calc_srp_u(B);
+	if (state->gnutls_key->u==NULL) {
+		gnutls_assert();
+		gnutls_free( *data);
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
 	/* S = (A * v^u) ^ b % N */
 	S = _gnutls_calc_srp_S1( A, _b, state->gnutls_key->u, V, N);
+	if ( S==NULL) {
+		gnutls_assert();
+		gnutls_free( *data);
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
-	mpi_release(A);
-	mpi_release(_b);
-	mpi_release(V);
-	mpi_release(state->gnutls_key->u);
-	mpi_release(B);
+	_gnutls_mpi_release(&A);
+	_gnutls_mpi_release(&_b);
+	_gnutls_mpi_release(&V);
+	_gnutls_mpi_release(&state->gnutls_key->u);
+	_gnutls_mpi_release(&B);
 
 	ret = _gnutls_generate_key( state->gnutls_key);
 	_gnutls_mpi_release( &S);
@@ -245,6 +259,10 @@ int gen_srp_client_kx0(GNUTLS_STATE state, opaque ** data)
 	}
 	
 	A = _gnutls_calc_srp_A( &_a, G, N);
+	if (A==NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
 	if (gcry_mpi_print(GCRYMPI_FMT_USG, NULL, &n_a, A)!=0)
 		return GNUTLS_E_MPI_PRINT_FAILED;
@@ -276,7 +294,7 @@ int proc_srp_server_hello(GNUTLS_STATE state, const opaque * data, int data_size
 	const uint8 *data_g;
 	const uint8 *data_s;
 	uint8 pwd_algo;
-	int i;
+	int i, ret;
 	opaque hd[SRP_MAX_HASH_SIZE];
 	char *username;
 	char *password;
@@ -344,7 +362,10 @@ int proc_srp_server_hello(GNUTLS_STATE state, const opaque * data, int data_size
 	/* generate x = SHA(s | SHA(U | ":" | p))
 	 * (or the equivalent using bcrypt)
 	 */
-	_gnutls_calc_srp_x( username, password, (opaque*)data_s, n_s, pwd_algo, &_n_g, hd);
+	if ( ( ret =_gnutls_calc_srp_x( username, password, (opaque*)data_s, n_s, pwd_algo, &_n_g, hd)) < 0) {
+		gnutls_assert();
+		return ret;
+	}
 
 	if (gcry_mpi_scan(&state->gnutls_key->x, GCRYMPI_FMT_USG, hd, &_n_g) != 0 || state->gnutls_key->x==NULL) {
 		gnutls_assert();
@@ -384,15 +405,24 @@ int proc_srp_server_kx2(GNUTLS_STATE state, opaque * data, int data_size)
 
 	/* calculate u */
 	state->gnutls_key->u = _gnutls_calc_srp_u( B);
+	if ( state->gnutls_key->u == NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
 	/* S = (B - g^x) ^ (a + u * x) % N */
 	S = _gnutls_calc_srp_S2( B, G, state->gnutls_key->x, _a, state->gnutls_key->u, N);
+	if (S==NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
+	
 
-	mpi_release(A);
-	mpi_release(_b);
-	mpi_release(V);
-	mpi_release(state->gnutls_key->u);
-	mpi_release(B);
+	_gnutls_mpi_release(&A);
+	_gnutls_mpi_release(&_b);
+	_gnutls_mpi_release(&V);
+	_gnutls_mpi_release(&state->gnutls_key->u);
+	_gnutls_mpi_release(&B);
 
 	ret = _gnutls_generate_key( state->gnutls_key);
 	_gnutls_mpi_release(&S);
diff --git a/lib/auth_srp_passwd.c b/lib/auth_srp_passwd.c
index 902c70794d..7cbdf945d6 100644
--- a/lib/auth_srp_passwd.c
+++ b/lib/auth_srp_passwd.c
@@ -162,7 +162,7 @@ int tmp_size;
 	/* now go for n - modulo */
 	p = rindex( str, ':'); /* we have n */
 	if (p==NULL) {
-		mpi_release(entry->g);
+		_gnutls_mpi_release(&entry->g);
 		gnutls_assert();
 		return GNUTLS_E_PARSING_ERROR;
 	}
@@ -175,13 +175,13 @@ int tmp_size;
 
 	if (tmp_size < 0) {
 		gnutls_assert();
-		mpi_release(entry->g);
+		_gnutls_mpi_release(&entry->g);
 		return GNUTLS_E_PARSING_ERROR;
 	}
 	if (gcry_mpi_scan(&entry->n, GCRYMPI_FMT_USG, tmp, &tmp_size) || entry->n==NULL) {
 		gnutls_assert();
 		gnutls_free(tmp);
-		mpi_release(entry->g);
+		_gnutls_mpi_release(&entry->g);
 		return GNUTLS_E_MPI_SCAN_FAILED;
 	}
 
@@ -235,6 +235,12 @@ GNUTLS_SRP_PWD_ENTRY *_gnutls_srp_pwd_read_entry( GNUTLS_KEY key, char* username
 	GNUTLS_SRP_PWD_ENTRY * entry = gnutls_malloc(sizeof(GNUTLS_SRP_PWD_ENTRY));
 	int index;
 
+	if (entry==NULL) {
+		gnutls_assert();
+		*err = 1;
+		return NULL;
+	}
+
 	*err = 0; /* normal exit */
 	
 	cred = _gnutls_get_cred( key, GNUTLS_SRP, NULL);
@@ -283,11 +289,30 @@ GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
 	GNUTLS_SRP_PWD_ENTRY * pwd_entry = gnutls_malloc(sizeof(GNUTLS_SRP_PWD_ENTRY));
 	size_t n = sizeof diffie_hellman_group1_prime;
 	
+	if (pwd_entry == NULL) {
+		gnutls_assert(); 
+		return NULL;
+	}
+	
 	pwd_entry->username = gnutls_malloc(strlen(RNDUSER)+1);
+	if (pwd_entry->username == NULL) {
+		gnutls_assert();
+		return NULL;
+	}
 	strcpy( pwd_entry->username, RNDUSER);
 	
 	pwd_entry->g = gcry_mpi_set_ui(NULL, SRP_G);
+	if (pwd_entry->g==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
+	
 	pwd_entry->v = gcry_mpi_new(160);
+	if (pwd_entry->v==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
+
         gcry_mpi_randomize( pwd_entry->v, 160, GCRY_WEAK_RANDOM);
 
 	if (gcry_mpi_scan(&pwd_entry->n, GCRYMPI_FMT_USG,
@@ -299,6 +324,11 @@ GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
 	pwd_entry->salt_size = RND_SALT_SIZE;
 	
 	pwd_entry->salt = gnutls_malloc(RND_SALT_SIZE);
+	if (pwd_entry->salt==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
+	
 	if (_gnutls_get_random(pwd_entry->salt, RND_SALT_SIZE, GNUTLS_WEAK_RANDOM) < 0) {
 		gnutls_assert();
 		return NULL;
@@ -310,9 +340,9 @@ GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
 }
 
 void _gnutls_srp_clear_pwd_entry( GNUTLS_SRP_PWD_ENTRY * entry) {
-	mpi_release(entry->v);
-	mpi_release(entry->g);
-	mpi_release(entry->n);
+	_gnutls_mpi_release(&entry->v);
+	_gnutls_mpi_release(&entry->g);
+	_gnutls_mpi_release(&entry->n);
 	
 	gnutls_free(entry->salt);
 	gnutls_free(entry->username);
diff --git a/lib/crypt_bcrypt.c b/lib/crypt_bcrypt.c
index eb017f8466..d30b2fb63f 100644
--- a/lib/crypt_bcrypt.c
+++ b/lib/crypt_bcrypt.c
@@ -578,6 +578,9 @@ static blf_ctx *_blf_init(uint8 * salt, const char *key, int key_len,
 	blf_ctx *state = gnutls_malloc(sizeof(blf_ctx));
 	uint32 i, rcost;
 
+	if (state==NULL)
+		return NULL;
+		
 	rcost = (uint32) 1 << cost;	/* 2^cost */
 
 	initialize_blowfish(state);
@@ -645,6 +648,10 @@ char *crypt_bcrypt(const char* username, const char *passwd, const char *salt, M
 	ctx = _blf_init(&csalt[1], passwd, passwd_len, cost);
 	gnutls_free(csalt);
 
+	if (ctx==NULL) {
+		return NULL;
+	}
+
 	for (i = 0; i < 64; i++) {
 		_blf_encrypt(ctx, (uint8 *) text);
 		_blf_encrypt(ctx, (uint8 *) & text[8]);
@@ -740,7 +747,10 @@ int _gnutls_calc_srp_bcrypt(const char* username, const char *passwd, opaque * s
 		passwd_len = 56;
 
 	ctx = _blf_init(&salt[1], passwd, passwd_len, (int)(salt[0]));
-
+	if (ctx==NULL) {
+		return GNUTLS_E_MEMORY_ERROR;
+	}
+	
 	for (i = 0; i < 64; i++) {
 		_blf_encrypt(ctx, (uint8 *) text);
 		_blf_encrypt(ctx, (uint8 *) & text[8]);
diff --git a/lib/gnutls_buffers.c b/lib/gnutls_buffers.c
index 2b1a22f4fc..20701b6458 100644
--- a/lib/gnutls_buffers.c
+++ b/lib/gnutls_buffers.c
@@ -43,7 +43,7 @@ int gnutls_insertDataBuffer(ContentType type, GNUTLS_STATE state, char *data, in
 	_gnutls_log( "RECORD BUFFER: Inserted %d bytes of Data(%d)\n", length, type);
 #endif
 		state->gnutls_internals.buffer.data =
-		    gnutls_realloc(state->gnutls_internals.buffer.data,
+		    gnutls_realloc_fast(state->gnutls_internals.buffer.data,
 			   state->gnutls_internals.buffer.size);
 		memcpy(&state->gnutls_internals.buffer.data[old_buffer], data, length);
 	}
@@ -55,7 +55,7 @@ int gnutls_insertDataBuffer(ContentType type, GNUTLS_STATE state, char *data, in
 	_gnutls_log( "HANDSHAKE BUFFER: Inserted %d bytes of Data(%d)\n", length, type);
 #endif
 		state->gnutls_internals.buffer_handshake.data =
-		    gnutls_realloc(state->gnutls_internals.buffer_handshake.data,
+		    gnutls_realloc_fast(state->gnutls_internals.buffer_handshake.data,
 			   state->gnutls_internals.buffer_handshake.size);
 		memcpy(&state->gnutls_internals.buffer_handshake.data[old_buffer], data, length);
 	}
@@ -106,7 +106,7 @@ int gnutls_getDataFromBuffer(ContentType type, GNUTLS_STATE state, char *data, i
 			&state->gnutls_internals.buffer.data[length],
 			state->gnutls_internals.buffer.size);
 		state->gnutls_internals.buffer.data =
-		    gnutls_realloc(state->gnutls_internals.buffer.data,
+		    gnutls_realloc_fast(state->gnutls_internals.buffer.data,
 				   state->gnutls_internals.buffer.size);
 	}
 	if (type == GNUTLS_HANDSHAKE) {
@@ -124,7 +124,7 @@ int gnutls_getDataFromBuffer(ContentType type, GNUTLS_STATE state, char *data, i
 			&state->gnutls_internals.buffer_handshake.data[length],
 			state->gnutls_internals.buffer_handshake.size);
 		state->gnutls_internals.buffer_handshake.data =
-		    gnutls_realloc(state->gnutls_internals.buffer_handshake.data,
+		    gnutls_realloc_fast(state->gnutls_internals.buffer_handshake.data,
 				   state->gnutls_internals.buffer_handshake.size);
 	}
 
@@ -272,7 +272,7 @@ int gnutls_insertHashDataBuffer( GNUTLS_STATE state, char *data, int length)
 	_gnutls_log( "HASH BUFFER: Inserted %d bytes of Data\n", length);
 #endif
 	state->gnutls_internals.hash_buffer.data =
-		    gnutls_realloc(state->gnutls_internals.hash_buffer.data,
+		    gnutls_realloc_fast(state->gnutls_internals.hash_buffer.data,
 			   state->gnutls_internals.hash_buffer.size);
 			   
 	if (state->gnutls_internals.hash_buffer.data == NULL) {
@@ -305,7 +305,7 @@ int gnutls_getHashDataFromBuffer( GNUTLS_STATE state, char *data, int length)
 		&state->gnutls_internals.hash_buffer.data[length],
 		state->gnutls_internals.hash_buffer.size);
 	state->gnutls_internals.hash_buffer.data =
-	    gnutls_realloc(state->gnutls_internals.hash_buffer.data,
+	    gnutls_realloc_fast(state->gnutls_internals.hash_buffer.data,
 			   state->gnutls_internals.hash_buffer.size);
 
 	if (state->gnutls_internals.hash_buffer.data == NULL) {
diff --git a/lib/gnutls_dh.c b/lib/gnutls_dh.c
index 8a2297675a..7beda092d4 100644
--- a/lib/gnutls_dh.c
+++ b/lib/gnutls_dh.c
@@ -255,10 +255,19 @@ MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
 	int x_size = get_x_size( gcry_mpi_get_nbits(prime));
 	
 	x = gcry_mpi_new(x_size);	/* FIXME: allocate in secure memory */
+	if ( x == NULL) {
+		if (ret_x) *ret_x = NULL;
+		return NULL;
+	}
+			
 	gcry_mpi_randomize(x, x_size, GCRY_STRONG_RANDOM);
 	/* fixme: set high bit of x and select a larger one */
 
 	e = gcry_mpi_alloc_like(prime);
+	if (e==NULL) {
+		if (ret_x) *ret_x = NULL;
+		return NULL;
+	}
 	gcry_mpi_powm(e, g, x, prime);
 
 	if (ret_x)
@@ -293,6 +302,8 @@ MPI gnutls_get_dh_params(MPI * ret_p, int bits)
 		}
 
 		g = gcry_mpi_set_ui(NULL, DH_G_1024);
+		if (g==NULL)
+			return NULL;
 
 		if (ret_p)
 			*ret_p = prime;
@@ -309,7 +320,9 @@ MPI gnutls_get_dh_params(MPI * ret_p, int bits)
 		}
 
 		g = gcry_mpi_set_ui(NULL, DH_G_2048);
-
+		if (g==NULL)
+			return NULL;
+			
 		if (ret_p)
 			*ret_p = prime;
 		else
@@ -325,6 +338,8 @@ MPI gnutls_get_dh_params(MPI * ret_p, int bits)
 		}
 
 		g = gcry_mpi_set_ui(NULL, DH_G_3072);
+		if (g==NULL)
+			return NULL;
 
 		if (ret_p)
 			*ret_p = prime;
@@ -341,6 +356,8 @@ MPI gnutls_get_dh_params(MPI * ret_p, int bits)
 		}
 
 		g = gcry_mpi_set_ui(NULL, DH_G_4096);
+		if (g==NULL)
+			return NULL;
 
 		if (ret_p)
 			*ret_p = prime;
@@ -359,6 +376,8 @@ MPI gnutls_calc_dh_key(MPI f, MPI x, MPI prime)
 	MPI k;
 
 	k = gcry_mpi_alloc_like(prime);
+	if (k==NULL)
+		return NULL;
 	gcry_mpi_powm(k, f, x, prime);
 	return k;
 }
diff --git a/lib/gnutls_handshake.c b/lib/gnutls_handshake.c
index 8cafba52b4..49445002f6 100644
--- a/lib/gnutls_handshake.c
+++ b/lib/gnutls_handshake.c
@@ -1739,8 +1739,6 @@ int _gnutls_remove_unwanted_ciphersuites(GNUTLS_STATE state,
 	int alg_size;
 	KXAlgorithm kx;
 
-#warning "make this function work to the client side too"
-
 	if (state->security_parameters.entity == GNUTLS_CLIENT)
 		 return 0;
 
diff --git a/lib/gnutls_mem.c b/lib/gnutls_mem.c
index 1c64409f26..7bb9a6b376 100644
--- a/lib/gnutls_mem.c
+++ b/lib/gnutls_mem.c
@@ -77,6 +77,19 @@ opaque* ptr = _ptr;
 
 void* gnutls_realloc( void* ptr, size_t size) {
 void* ret;
+	ret = gnutls_malloc( size);
+	if (ret==NULL) return ret;
+	
+	if (ptr!=NULL) {
+		memcpy( ret, ptr, GMIN( _gnutls_malloc_ptr_size(ptr), size));
+		gnutls_free(ptr);
+	}
+	
+	return ret;
+}
+
+void* gnutls_realloc_fast( void* ptr, size_t size) {
+void* ret;
 	if ( ptr != NULL && size <= _gnutls_malloc_ptr_size(ptr)) {
 		/* do nothing, just return the pointer.
 		 * It's much faster.
diff --git a/lib/gnutls_mem.h b/lib/gnutls_mem.h
index a352defad0..920a9fe5b4 100644
--- a/lib/gnutls_mem.h
+++ b/lib/gnutls_mem.h
@@ -7,6 +7,7 @@ typedef void svoid; /* for functions that allocate using secure_free */
 #ifdef USE_DMALLOC
 # define gnutls_malloc malloc
 # define gnutls_realloc realloc
+# define gnutls_realloc_fast realloc
 # define gnutls_free free
 # define gnutls_calloc calloc
 # define secure_malloc malloc
@@ -29,6 +30,7 @@ void* gnutls_malloc( size_t size);
 void* gnutls_calloc( size_t nmemb, size_t size);
 size_t _gnutls_malloc_ptr_size( void* ptr);
 void* gnutls_realloc( void* ptr, size_t size);
+void* gnutls_realloc_fast( void* ptr, size_t size);
 void gnutls_free( void* ptr);
 char* gnutls_strdup( const char* s);
 
diff --git a/lib/gnutls_srp.c b/lib/gnutls_srp.c
index d93f158d21..57a1ca0342 100644
--- a/lib/gnutls_srp.c
+++ b/lib/gnutls_srp.c
@@ -69,9 +69,16 @@ int _gnutls_srp_gn(opaque ** ret_g, opaque ** ret_n, int bits)
 			return GNUTLS_E_MPI_SCAN_FAILED;
 		}
 		g = gcry_mpi_set_ui(NULL, SRP_G);
-
+		if (g==NULL) {
+			gnutls_assert();
+			return GNUTLS_E_MEMORY_ERROR;
+		}
 	} else {
 		g = mpi_new(16); /* this should be ok */
+		if (g==NULL) {
+			gnutls_assert();
+			return GNUTLS_E_MEMORY_ERROR;
+		}
 
 		/* generate a random prime */
 		/* this is an emulation of Michael Wiener's table
@@ -137,6 +144,11 @@ int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, MPI g,
 	}
 
 	e = gcry_mpi_alloc_like(prime);
+	if (e==NULL) {
+		gnutls_assert();
+		_gnutls_mpi_release(&x);
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 
 	/* e = g^x mod prime (n) */
 	gcry_mpi_powm(e, g, x, prime);
@@ -170,10 +182,28 @@ MPI _gnutls_calc_srp_B(MPI * ret_b, MPI g, MPI n, MPI v)
 	/* calculate:  B = (v + g^b) % N */
 	bits = gcry_mpi_get_nbits(n);
 	b = gcry_mpi_new(bits);	/* FIXME: allocate in secure memory */
+	if (b==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
+	
 	gcry_mpi_randomize(b, bits, GCRY_STRONG_RANDOM);
 
 	tmpB = gcry_mpi_new(bits);	/* FIXME: allocate in secure memory */
+	if (tmpB==NULL) {
+		gnutls_assert();
+		_gnutls_mpi_release( &b);
+		return NULL;
+	}
+
 	B = gcry_mpi_new(bits);	/* FIXME: allocate in secure memory */
+	if (tmpB==NULL) {
+		gnutls_assert();
+		_gnutls_mpi_release( &b);
+		_gnutls_mpi_release( &tmpB);
+		return NULL;
+	}
+
 	gcry_mpi_powm(tmpB, g, b, n);
 	gcry_mpi_addm(B, v, tmpB, n);
 
@@ -216,6 +246,10 @@ MPI _gnutls_calc_srp_u(MPI B)
 	gnutls_free(b_holder);
 
 	ret = gcry_mpi_set_ui(NULL, u);
+	if (ret==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
 
 	return ret;
 }
@@ -229,9 +263,18 @@ MPI _gnutls_calc_srp_S1(MPI A, MPI b, MPI u, MPI v, MPI n)
 	MPI S;
 
 	S = gcry_mpi_alloc_like(n);
+	if (S==NULL)
+		return NULL;
+
 	tmp1 = gcry_mpi_alloc_like(n);
 	tmp2 = gcry_mpi_alloc_like(n);
 
+	if (tmp1 == NULL || tmp2 == NULL) {
+		_gnutls_mpi_release(&tmp1);
+		_gnutls_mpi_release(&tmp2);
+		return NULL;
+	}
+
 	gcry_mpi_powm(tmp1, v, u, n);
 	gcry_mpi_mulm(tmp2, A, tmp1, n);
 	_gnutls_mpi_release(&tmp1);
@@ -253,9 +296,19 @@ MPI _gnutls_calc_srp_A(MPI * a, MPI g, MPI n)
 
 	bits = gcry_mpi_get_nbits(n);
 	tmpa = gcry_mpi_new(bits);	/* FIXME: allocate in secure memory */
+	if (tmpa==NULL) {
+		gnutls_assert();
+		return NULL;
+	}
+	
 	gcry_mpi_randomize(tmpa, bits, GCRY_STRONG_RANDOM);
 
 	A = gcry_mpi_new(bits);	/* FIXME: allocate in secure memory */
+	if (A==NULL) {
+		gnutls_assert();
+		_gnutls_mpi_release( &tmpa);
+		return NULL;
+	}
 	gcry_mpi_powm(A, g, tmpa, n);
 
 	if (a != NULL)
@@ -278,6 +331,9 @@ int _gnutls_calc_srp_sha(char *username, char *password, opaque * salt,
 	*size = 20;
 
 	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	if (td==NULL) {
+		return GNUTLS_E_MEMORY_ERROR;
+	}
 	gnutls_hash(td, username, strlen(username));
 	gnutls_hash(td, ":", 1);
 	gnutls_hash(td, password, strlen(password));
@@ -285,6 +341,10 @@ int _gnutls_calc_srp_sha(char *username, char *password, opaque * salt,
 	gnutls_hash_deinit(td, res);
 
 	td = gnutls_hash_init(GNUTLS_MAC_SHA);
+	if (td==NULL) {
+		return GNUTLS_E_MEMORY_ERROR;
+	}
+
 	gnutls_hash(td, salt, salt_size);
 	gnutls_hash(td, res, 20);	/* 20 bytes is the output of sha1 */
 	gnutls_free(res);
@@ -318,14 +378,24 @@ MPI _gnutls_calc_srp_S2(MPI B, MPI g, MPI x, MPI a, MPI u, MPI n)
 	MPI S, tmp1, tmp2, tmp4;
 
 	S = gcry_mpi_alloc_like(n);
+	if (S==NULL)
+		return NULL;
+		
 	tmp1 = gcry_mpi_alloc_like(n);
 	tmp2 = gcry_mpi_alloc_like(n);
+	if (tmp1 == NULL || tmp2 == NULL) {
+		_gnutls_mpi_release(&tmp1);
+		_gnutls_mpi_release(&tmp2);
+		return NULL;
+	}
 
 	gcry_mpi_powm(tmp1, g, x, n);
 
 	gcry_mpi_subm(tmp2, B, tmp1, n);
 
 	tmp4 = gcry_mpi_alloc_like(n);
+	if (tmp4==NULL)
+		return NULL;
 
 	gcry_mpi_mul(tmp1, u, x);
 	gcry_mpi_add(tmp4, a, tmp1);