From: Nikos Mavrogiannopoulos <nmav@gnutls.org>
Date: Sun, 26 Jan 2014 08:06:14 +0000 (+0100)
Subject: Updated _gnutls_mpi_init prototype and added _gnutls_mpi_init_multi
X-Git-Tag: gnutls_3_3_0pre0~278
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=a02809a1a715e65fcd4a3e1577dfdbc5ab43ed66;p=thirdparty%2Fgnutls.git

Updated _gnutls_mpi_init prototype and added _gnutls_mpi_init_multi
---

diff --git a/lib/auth/srp.c b/lib/auth/srp.c
index 702b94052c..3966b0b9b2 100644
--- a/lib/auth/srp.c
+++ b/lib/auth/srp.c
@@ -722,17 +722,10 @@ group_check_g_n(gnutls_session_t session, bigint_t g, bigint_t n)
 		return GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER;
 	}
 
-	two = _gnutls_mpi_new(4);
-	if (two == NULL) {
-		gnutls_assert();
-		return GNUTLS_E_MEMORY_ERROR;
-	}
-
-	q = _gnutls_mpi_alloc_like(n);
-	if (q == NULL) {
+	ret = _gnutls_mpi_init_multi(&two, &q, &w, NULL);
+	if (ret < 0) {
 		gnutls_assert();
-		ret = GNUTLS_E_MEMORY_ERROR;
-		goto error;
+		return ret;
 	}
 
 	/* q = n-1 
@@ -763,13 +756,6 @@ group_check_g_n(gnutls_session_t session, bigint_t g, bigint_t n)
 		goto error;
 	}
 
-	w = _gnutls_mpi_alloc_like(q);
-	if (w == NULL) {
-		gnutls_assert();
-		ret = GNUTLS_E_MEMORY_ERROR;
-		goto error;
-	}
-
 	/* check if g^q mod N == N-1
 	 * w = g^q mod N
 	 */
diff --git a/lib/crypto-backend.h b/lib/crypto-backend.h
index a497f56146..25fdeb07e3 100644
--- a/lib/crypto-backend.h
+++ b/lib/crypto-backend.h
@@ -105,7 +105,8 @@ typedef enum {
 
 /* Multi precision integer arithmetic */
 typedef struct gnutls_crypto_bigint {
-	bigint_t(*bigint_new) (int nbits);
+	int (*bigint_init) (bigint_t*);
+	int (*bigint_init_multi) (bigint_t*, ...);
 	void (*bigint_release) (bigint_t n);
 	void (*bigint_clear) (bigint_t n);	/* zeros the int */
 	/* 0 for equality, > 0 for m1>m2, < 0 for m1<m2 */
diff --git a/lib/gnutls_mpi.h b/lib/gnutls_mpi.h
index f0a20790d3..3d59e464f9 100644
--- a/lib/gnutls_mpi.h
+++ b/lib/gnutls_mpi.h
@@ -33,7 +33,8 @@ extern gnutls_crypto_bigint_st _gnutls_mpi_ops;
 bigint_t _gnutls_mpi_random_modp(bigint_t, bigint_t p,
 			       gnutls_rnd_level_t level);
 
-#define _gnutls_mpi_new _gnutls_mpi_ops.bigint_new
+#define _gnutls_mpi_init _gnutls_mpi_ops.bigint_init
+#define _gnutls_mpi_init_multi _gnutls_mpi_ops.bigint_init_multi
 #define _gnutls_mpi_clear _gnutls_mpi_ops.bigint_clear
 #define _gnutls_mpi_cmp _gnutls_mpi_ops.bigint_cmp
 #define _gnutls_mpi_cmp_ui _gnutls_mpi_ops.bigint_cmp_ui
@@ -42,7 +43,6 @@ bigint_t _gnutls_mpi_random_modp(bigint_t, bigint_t p,
 #define _gnutls_mpi_set _gnutls_mpi_ops.bigint_set
 #define _gnutls_mpi_set_ui _gnutls_mpi_ops.bigint_set_ui
 #define _gnutls_mpi_get_nbits _gnutls_mpi_ops.bigint_get_nbits
-#define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(_gnutls_mpi_get_nbits(x))
 #define _gnutls_mpi_powm _gnutls_mpi_ops.bigint_powm
 #define _gnutls_mpi_addm _gnutls_mpi_ops.bigint_addm
 #define _gnutls_mpi_subm _gnutls_mpi_ops.bigint_subm
diff --git a/lib/gnutls_srp.c b/lib/gnutls_srp.c
index 8b26afc945..19b0d7b7ba 100644
--- a/lib/gnutls_srp.c
+++ b/lib/gnutls_srp.c
@@ -53,12 +53,9 @@ _gnutls_srp_gx(uint8_t * text, size_t textsize, uint8_t ** result,
 		return GNUTLS_E_MPI_SCAN_FAILED;
 	}
 
-	e = _gnutls_mpi_alloc_like(prime);
-	if (e == NULL) {
-		gnutls_assert();
-		_gnutls_mpi_release(&x);
-		return GNUTLS_E_MEMORY_ERROR;
-	}
+	ret = _gnutls_mpi_init(&e);
+	if (ret < 0)
+		return gnutls_assert_val(ret);
 
 	/* e = g^x mod prime (n) */
 	_gnutls_mpi_powm(e, g, x, prime);
@@ -94,33 +91,15 @@ _gnutls_calc_srp_B(bigint_t * ret_b, bigint_t g, bigint_t n, bigint_t v)
 {
 	bigint_t tmpB = NULL, tmpV = NULL;
 	bigint_t b = NULL, B = NULL, k = NULL;
-	int bits;
-
+	int ret;
 
 	/* calculate:  B = (k*v + g^b) % N 
 	 */
-	bits = _gnutls_mpi_get_nbits(n);
-
-	tmpV = _gnutls_mpi_alloc_like(n);
-
-	if (tmpV == NULL) {
-		gnutls_assert();
-		goto error;
-	}
-
-	b = _gnutls_mpi_random_modp(NULL, n, GNUTLS_RND_RANDOM);
-
-	tmpB = _gnutls_mpi_new(bits);
-	if (tmpB == NULL) {
-		gnutls_assert();
-		goto error;
-	}
+	ret = _gnutls_mpi_init_multi(&tmpV, &tmpB, &B, &b, NULL);
+	if (ret < 0)
+		return NULL;
 
-	B = _gnutls_mpi_new(bits);
-	if (B == NULL) {
-		gnutls_assert();
-		goto error;
-	}
+	_gnutls_mpi_random_modp(b, n, GNUTLS_RND_RANDOM);
 
 	k = _gnutls_calc_srp_u(n, g, n);
 	if (k == NULL) {
@@ -215,17 +194,12 @@ _gnutls_calc_srp_S1(bigint_t A, bigint_t b, bigint_t u, bigint_t v,
 {
 	bigint_t tmp1 = NULL, tmp2 = NULL;
 	bigint_t S = NULL;
+	int ret;
 
-	S = _gnutls_mpi_alloc_like(n);
-	if (S == NULL)
+	ret = _gnutls_mpi_init_multi(&S, &tmp1, &tmp2, NULL);
+	if (ret < 0)
 		return NULL;
 
-	tmp1 = _gnutls_mpi_alloc_like(n);
-	tmp2 = _gnutls_mpi_alloc_like(n);
-
-	if (tmp1 == NULL || tmp2 == NULL)
-		goto freeall;
-
 	_gnutls_mpi_powm(tmp1, v, u, n);
 	_gnutls_mpi_mulm(tmp2, A, tmp1, n);
 	_gnutls_mpi_powm(S, tmp2, b, n);
@@ -234,11 +208,6 @@ _gnutls_calc_srp_S1(bigint_t A, bigint_t b, bigint_t u, bigint_t v,
 	_gnutls_mpi_release(&tmp2);
 
 	return S;
-
-      freeall:
-	_gnutls_mpi_release(&tmp1);
-	_gnutls_mpi_release(&tmp2);
-	return NULL;
 }
 
 /* A = g^a % N 
@@ -248,17 +217,16 @@ bigint_t _gnutls_calc_srp_A(bigint_t * a, bigint_t g, bigint_t n)
 {
 	bigint_t tmpa;
 	bigint_t A;
-	int bits;
-
-	bits = _gnutls_mpi_get_nbits(n);
-	tmpa = _gnutls_mpi_random_modp(NULL, n, GNUTLS_RND_RANDOM);
+	int ret;
 
-	A = _gnutls_mpi_new(bits);
-	if (A == NULL) {
+	ret = _gnutls_mpi_init_multi(&A, &tmpa, NULL);
+	if (ret < 0) {
 		gnutls_assert();
-		_gnutls_mpi_release(&tmpa);
 		return NULL;
 	}
+
+	_gnutls_mpi_random_modp(tmpa, n, GNUTLS_RND_RANDOM);
+
 	_gnutls_mpi_powm(A, g, tmpa, n);
 
 	if (a != NULL)
@@ -326,18 +294,12 @@ _gnutls_calc_srp_S2(bigint_t B, bigint_t g, bigint_t x, bigint_t a,
 {
 	bigint_t S = NULL, tmp1 = NULL, tmp2 = NULL;
 	bigint_t tmp4 = NULL, tmp3 = NULL, k = NULL;
+	int ret;
 
-	S = _gnutls_mpi_alloc_like(n);
-	if (S == NULL)
+	ret = _gnutls_mpi_init_multi(&S, &tmp1, &tmp2, &tmp3, &tmp4, NULL);
+	if (ret < 0)
 		return NULL;
 
-	tmp1 = _gnutls_mpi_alloc_like(n);
-	tmp2 = _gnutls_mpi_alloc_like(n);
-	tmp3 = _gnutls_mpi_alloc_like(n);
-	if (tmp1 == NULL || tmp2 == NULL || tmp3 == NULL) {
-		goto freeall;
-	}
-
 	k = _gnutls_calc_srp_u(n, g, n);
 	if (k == NULL) {
 		gnutls_assert();
@@ -348,10 +310,6 @@ _gnutls_calc_srp_S2(bigint_t B, bigint_t g, bigint_t x, bigint_t a,
 	_gnutls_mpi_mulm(tmp3, tmp1, k, n);	/* k*g^x mod n */
 	_gnutls_mpi_subm(tmp2, B, tmp3, n);
 
-	tmp4 = _gnutls_mpi_alloc_like(n);
-	if (tmp4 == NULL)
-		goto freeall;
-
 	_gnutls_mpi_mul(tmp1, u, x);
 	_gnutls_mpi_add(tmp4, a, tmp1);
 	_gnutls_mpi_powm(S, tmp2, tmp4, n);
diff --git a/lib/nettle/mpi.c b/lib/nettle/mpi.c
index 034c74edf3..c4645ac1f5 100644
--- a/lib/nettle/mpi.c
+++ b/lib/nettle/mpi.c
@@ -72,32 +72,88 @@ wrap_nettle_mpi_print(const bigint_t a, void *buffer, size_t * nbytes,
 	return 0;
 }
 
-static bigint_t wrap_nettle_mpi_new(int nbits)
+static int wrap_nettle_mpi_init(bigint_t *w)
 {
-	mpz_t *p;
+mpz_t *r;
 
-	p = gnutls_malloc(sizeof(*p));
-	if (p == NULL) {
+	r = gnutls_malloc(sizeof(*r));
+	if (r == NULL) {
 		gnutls_assert();
-		return NULL;
+		return GNUTLS_E_MEMORY_ERROR;
 	}
-	if (nbits == 0)
-		mpz_init(*p);
-	else
-		mpz_init2(*p, nbits);
 
-	return p;
+	mpz_init(*r);
+	
+	*w = r;
+
+	return 0;
+}
+
+static int wrap_nettle_mpi_init_multi(bigint_t *w, ...)
+{
+	va_list args;
+	bigint_t *next;
+	mpz_t *r;
+	bigint_t* last_failed = NULL;
+
+	r = gnutls_malloc(sizeof(*r));
+	if (r == NULL) {
+		gnutls_assert();
+		return GNUTLS_E_MEMORY_ERROR;
+	}
+
+	mpz_init(*r);
+	*w = r;
+	
+	va_start(args, w);
+	
+	do {
+		next = va_arg(args, bigint_t*);
+		if (next != NULL) {
+			r = gnutls_malloc(sizeof(*r));
+			if (r == NULL) {
+				gnutls_assert();
+				va_end(args);
+				last_failed = next;
+				goto fail;
+			}
+			mpz_init(*r);
+			*next = r;
+		}
+	} while(next != 0);
+	
+	va_end(args);
+
+	return 0;
+fail:
+	mpz_clear(TOMPZ(*w));
+	gnutls_free(*w);
+	va_start(args, w);
+	
+	do {
+		next = va_arg(args, bigint_t*);
+		if (next != last_failed) {
+			mpz_clear(TOMPZ(*next));
+			gnutls_free(*next);
+		}
+	} while(next != last_failed);
+	
+	va_end(args);
+	
+	return GNUTLS_E_MEMORY_ERROR;
 }
 
 static bigint_t
 wrap_nettle_mpi_scan(const void *buffer, size_t nbytes,
 		     gnutls_bigint_format_t format)
 {
-	bigint_t r = wrap_nettle_mpi_new(nbytes * 8);
-
-	if (r == NULL) {
+	int ret;
+	bigint_t r;
+	
+	ret = wrap_nettle_mpi_init(&r);
+	if (ret < 0) {
 		gnutls_assert();
-		return r;
+		return NULL;
 	}
 
 	if (format == GNUTLS_MPI_FORMAT_USG) {
@@ -150,9 +206,14 @@ static int wrap_nettle_mpi_cmp_ui(const bigint_t u, unsigned long v)
 static bigint_t wrap_nettle_mpi_set(bigint_t w, const bigint_t u)
 {
 	mpz_t *i1, *i2 = u;
+	int ret;
+
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
-	if (w == NULL)
-		w = _gnutls_mpi_alloc_like(u);
 	i1 = w;
 
 	mpz_set(*i1, *i2);
@@ -163,9 +224,13 @@ static bigint_t wrap_nettle_mpi_set(bigint_t w, const bigint_t u)
 static bigint_t wrap_nettle_mpi_set_ui(bigint_t w, unsigned long u)
 {
 	mpz_t *i1;
+	int ret;
 
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(32);
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	i1 = w;
 
@@ -193,11 +258,14 @@ static void wrap_nettle_mpi_clear(bigint_t a)
 
 static bigint_t wrap_nettle_mpi_modm(bigint_t r, const bigint_t a, const bigint_t b)
 {
+int ret;
+
 	if (r == NULL) {
-                r = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(b));
-                if (r == NULL) return NULL;
+		ret = wrap_nettle_mpi_init(&r);
+		if (ret < 0)
+			return NULL;
 	}
-	
+
 	mpz_mod(TOMPZ(r), TOMPZ(a), TOMPZ(b));
 	
 	return r;
@@ -207,11 +275,13 @@ static bigint_t
 wrap_nettle_mpi_powm(bigint_t w, const bigint_t b, const bigint_t e,
 		     const bigint_t m)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(m));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_powm(TOMPZ(w), TOMPZ(b), TOMPZ(e), TOMPZ(m));
 
@@ -222,11 +292,13 @@ static bigint_t
 wrap_nettle_mpi_addm(bigint_t w, const bigint_t a, const bigint_t b,
 		     const bigint_t m)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_add(TOMPZ(w), TOMPZ(b), TOMPZ(a));
 	mpz_fdiv_r(TOMPZ(w), TOMPZ(w), TOMPZ(m));
@@ -238,11 +310,13 @@ static bigint_t
 wrap_nettle_mpi_subm(bigint_t w, const bigint_t a, const bigint_t b,
 		     const bigint_t m)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_sub(TOMPZ(w), TOMPZ(a), TOMPZ(b));
 	mpz_fdiv_r(TOMPZ(w), TOMPZ(w), TOMPZ(m));
@@ -254,11 +328,13 @@ static bigint_t
 wrap_nettle_mpi_mulm(bigint_t w, const bigint_t a, const bigint_t b,
 		     const bigint_t m)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(m));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_mul(TOMPZ(w), TOMPZ(a), TOMPZ(b));
 	mpz_fdiv_r(TOMPZ(w), TOMPZ(w), TOMPZ(m));
@@ -269,11 +345,13 @@ wrap_nettle_mpi_mulm(bigint_t w, const bigint_t a, const bigint_t b,
 static bigint_t
 wrap_nettle_mpi_add(bigint_t w, const bigint_t a, const bigint_t b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(b));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_add(TOMPZ(w), TOMPZ(a), TOMPZ(b));
 
@@ -283,11 +361,13 @@ wrap_nettle_mpi_add(bigint_t w, const bigint_t a, const bigint_t b)
 static bigint_t
 wrap_nettle_mpi_sub(bigint_t w, const bigint_t a, const bigint_t b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_sub(TOMPZ(w), TOMPZ(a), TOMPZ(b));
 
@@ -297,11 +377,13 @@ wrap_nettle_mpi_sub(bigint_t w, const bigint_t a, const bigint_t b)
 static bigint_t
 wrap_nettle_mpi_mul(bigint_t w, const bigint_t a, const bigint_t b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_mul(TOMPZ(w), TOMPZ(a), TOMPZ(b));
 
@@ -312,11 +394,13 @@ wrap_nettle_mpi_mul(bigint_t w, const bigint_t a, const bigint_t b)
 static bigint_t
 wrap_nettle_mpi_div(bigint_t q, const bigint_t a, const bigint_t b)
 {
-	if (q == NULL)
-		q = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (q == NULL)
-		return NULL;
+	if (q == NULL) {
+		ret = wrap_nettle_mpi_init(&q);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_cdiv_q(TOMPZ(q), TOMPZ(a), TOMPZ(b));
 
@@ -326,11 +410,13 @@ wrap_nettle_mpi_div(bigint_t q, const bigint_t a, const bigint_t b)
 static bigint_t
 wrap_nettle_mpi_add_ui(bigint_t w, const bigint_t a, unsigned long b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_add_ui(TOMPZ(w), TOMPZ(a), b);
 
@@ -340,11 +426,13 @@ wrap_nettle_mpi_add_ui(bigint_t w, const bigint_t a, unsigned long b)
 static bigint_t
 wrap_nettle_mpi_sub_ui(bigint_t w, const bigint_t a, unsigned long b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_sub_ui(TOMPZ(w), TOMPZ(a), b);
 
@@ -355,11 +443,13 @@ wrap_nettle_mpi_sub_ui(bigint_t w, const bigint_t a, unsigned long b)
 static bigint_t
 wrap_nettle_mpi_mul_ui(bigint_t w, const bigint_t a, unsigned long b)
 {
-	if (w == NULL)
-		w = wrap_nettle_mpi_new(wrap_nettle_mpi_get_nbits(a));
+int ret;
 
-	if (w == NULL)
-		return NULL;
+	if (w == NULL) {
+		ret = wrap_nettle_mpi_init(&w);
+		if (ret < 0)
+			return NULL;
+	}
 
 	mpz_mul_ui(TOMPZ(w), TOMPZ(a), b);
 
@@ -370,8 +460,8 @@ wrap_nettle_mpi_mul_ui(bigint_t w, const bigint_t a, unsigned long b)
 static int wrap_nettle_prime_check(bigint_t pp)
 {
 	int ret;
-	ret = mpz_probab_prime_p(TOMPZ(pp), PRIME_CHECK_PARAM);
 
+	ret = mpz_probab_prime_p(TOMPZ(pp), PRIME_CHECK_PARAM);
 	if (ret > 0) {
 		return 0;
 	}
@@ -384,7 +474,8 @@ static int wrap_nettle_prime_check(bigint_t pp)
 int crypto_bigint_prio = INT_MAX;
 
 gnutls_crypto_bigint_st _gnutls_mpi_ops = {
-	.bigint_new = wrap_nettle_mpi_new,
+	.bigint_init = wrap_nettle_mpi_init,
+	.bigint_init_multi = wrap_nettle_mpi_init_multi,
 	.bigint_cmp = wrap_nettle_mpi_cmp,
 	.bigint_cmp_ui = wrap_nettle_mpi_cmp_ui,
 	.bigint_modm = wrap_nettle_mpi_modm,
diff --git a/lib/nettle/pk.c b/lib/nettle/pk.c
index adf6353577..72407fa37b 100644
--- a/lib/nettle/pk.c
+++ b/lib/nettle/pk.c
@@ -215,10 +215,9 @@ static int _wrap_nettle_pk_derive(gnutls_pk_algorithm_t algo,
 			goto dh_cleanup;
 		}
 
-		k = _gnutls_mpi_alloc_like(prime);
-		if (k == NULL) {
+		ret = _gnutls_mpi_init(&k);
+		if (ret < 0) {
 			gnutls_assert();
-			ret = GNUTLS_E_MEMORY_ERROR;
 			goto dh_cleanup;
 		}
 
@@ -825,15 +824,14 @@ wrap_nettle_pk_generate_params(gnutls_pk_algorithm_t algo,
 #endif
 
 			params->params_nr = 0;
-			for (i = 0; i < DSA_PRIVATE_PARAMS-2; i++) {
-				params->params[i] =
-				    _gnutls_mpi_alloc_like(&pub.p);
-				if (params->params[i] == NULL) {
-					ret = GNUTLS_E_MEMORY_ERROR;
-					goto dsa_fail;
-				}
-				params->params_nr++;
+			
+			ret = _gnutls_mpi_init_multi(&params->params[0], &params->params[1],
+					&params->params[2], NULL);
+			if (ret < 0) {
+				gnutls_assert();
+				goto dsa_fail;
 			}
+			params->params_nr = 3;
 
 			ret = 0;
 			_gnutls_mpi_set(params->params[0], pub.p);
@@ -908,16 +906,9 @@ wrap_nettle_pk_generate_keys(gnutls_pk_algorithm_t algo,
 				goto dsa_fail;
 			}
 
-			params->params[DSA_Y] = _gnutls_mpi_alloc_like(&pub.p);
-			if (params->params[DSA_Y] == NULL) {
-				ret = GNUTLS_E_MEMORY_ERROR;
-				goto dsa_fail;
-			}
-
-			params->params[DSA_X] = _gnutls_mpi_alloc_like(&pub.p);
-			if (params->params[DSA_X] == NULL) {
-				_gnutls_mpi_release(&params->params[DSA_Y]);
-				ret = GNUTLS_E_MEMORY_ERROR;
+			ret = _gnutls_mpi_init_multi(&params->params[DSA_Y], &params->params[DSA_X], NULL);
+			if (ret < 0) {
+				gnutls_assert();
 				goto dsa_fail;
 			}
 
@@ -985,16 +976,9 @@ wrap_nettle_pk_generate_keys(gnutls_pk_algorithm_t algo,
 				}
 			} while(mpz_cmp_ui(y, 1) == 0);
 
-			params->params[DSA_Y] = _gnutls_mpi_alloc_like(&pub.p);
-			if (params->params[DSA_Y] == NULL) {
-				ret = GNUTLS_E_MEMORY_ERROR;
-				goto dh_fail;
-			}
-
-			params->params[DSA_X] = _gnutls_mpi_alloc_like(&pub.p);
-			if (params->params[DSA_X] == NULL) {
-				_gnutls_mpi_release(&params->params[DSA_Y]);
-				ret = GNUTLS_E_MEMORY_ERROR;
+			ret = _gnutls_mpi_init_multi(&params->params[DSA_Y], &params->params[DSA_X], NULL);
+			if (ret < 0) {
+				gnutls_assert();
 				goto dh_fail;
 			}
 
@@ -1036,14 +1020,12 @@ wrap_nettle_pk_generate_keys(gnutls_pk_algorithm_t algo,
 
 			params->params_nr = 0;
 			for (i = 0; i < RSA_PRIVATE_PARAMS; i++) {
-				params->params[i] =
-				    _gnutls_mpi_alloc_like(&pub.n);
-				if (params->params[i] == NULL) {
-					ret = GNUTLS_E_MEMORY_ERROR;
+				ret = _gnutls_mpi_init(&params->params[i]);
+				if (ret < 0) {
+					gnutls_assert();
 					goto rsa_fail;
 				}
 				params->params_nr++;
-
 			}
 
 			ret = 0;
@@ -1083,20 +1065,10 @@ wrap_nettle_pk_generate_keys(gnutls_pk_algorithm_t algo,
 
 			ecdsa_generate_keypair(&pub, &key, NULL, rnd_func);
 
-			params->params[ECC_X] = _gnutls_mpi_new(0);
-			params->params[ECC_Y] = _gnutls_mpi_new(0);
-			params->params[ECC_K] = _gnutls_mpi_new(0);
-
-			if (params->params[ECC_X] == NULL
-			    || params->params[ECC_Y] == NULL
-			    || params->params[ECC_K] == NULL) {
-				_gnutls_mpi_release(&params->
-						    params[ECC_X]);
-				_gnutls_mpi_release(&params->
-						    params[ECC_Y]);
-				_gnutls_mpi_release(&params->
-						    params[ECC_K]);
-				ret = gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
+			ret = _gnutls_mpi_init_multi(&params->params[ECC_X], &params->params[ECC_Y], 
+					&params->params[ECC_K], NULL);
+			if (ret < 0) {
+				gnutls_assert();
 				goto ecc_fail;
 			}
 
@@ -1153,11 +1125,10 @@ wrap_nettle_pk_verify_params(gnutls_pk_algorithm_t algo,
 				    gnutls_assert_val
 				    (GNUTLS_E_INVALID_REQUEST);
 
-			t1 = _gnutls_mpi_new(256);
-			if (t1 == NULL)
+			ret = _gnutls_mpi_init(&t1);
+			if (ret < 0)
 				return
-				    gnutls_assert_val
-				    (GNUTLS_E_MEMORY_ERROR);
+				    gnutls_assert_val(ret);
 
 			_gnutls_mpi_mulm(t1, params->params[RSA_PRIME1],
 					 params->params[RSA_PRIME2],
@@ -1236,11 +1207,10 @@ wrap_nettle_pk_verify_params(gnutls_pk_algorithm_t algo,
 				    gnutls_assert_val
 				    (GNUTLS_E_INVALID_REQUEST);
 
-			t1 = _gnutls_mpi_new(256);
-			if (t1 == NULL)
+			ret = _gnutls_mpi_init(&t1);
+			if (ret < 0)
 				return
-				    gnutls_assert_val
-				    (GNUTLS_E_MEMORY_ERROR);
+				    gnutls_assert_val(ret);
 
 			_gnutls_mpi_powm(t1, params->params[DSA_G],
 					 params->params[DSA_X],
@@ -1338,17 +1308,17 @@ wrap_nettle_pk_verify_params(gnutls_pk_algorithm_t algo,
 
 static int calc_rsa_exp(gnutls_pk_params_st * params)
 {
-	bigint_t tmp = _gnutls_mpi_alloc_like(params->params[0]);
-
+	bigint_t tmp;
+	int ret;
+	
 	if (params->params_nr < RSA_PRIVATE_PARAMS - 2) {
 		gnutls_assert();
 		return GNUTLS_E_INTERNAL_ERROR;
 	}
 
-	if (tmp == NULL) {
-		gnutls_assert();
-		return GNUTLS_E_MEMORY_ERROR;
-	}
+	ret = _gnutls_mpi_init(&tmp);
+	if (ret < 0)
+		return gnutls_assert_val(ret);
 
 	/* [6] = d % p-1, [7] = d % q-1 */
 	_gnutls_mpi_sub_ui(tmp, params->params[3], 1);
diff --git a/lib/x509/privkey_pkcs8.c b/lib/x509/privkey_pkcs8.c
index 9b91ba9ea8..accf4ae411 100644
--- a/lib/x509/privkey_pkcs8.c
+++ b/lib/x509/privkey_pkcs8.c
@@ -1081,9 +1081,8 @@ _decode_pkcs8_dsa_key(ASN1_TYPE pkcs8_asn, gnutls_x509_privkey_t pkey)
 	}
 
 	/* the public key can be generated as g^x mod p */
-	pkey->params.params[3] =
-	    _gnutls_mpi_alloc_like(pkey->params.params[0]);
-	if (pkey->params.params[3] == NULL) {
+	ret = _gnutls_mpi_init(&pkey->params.params[3]);
+	if (ret < 0) {
 		gnutls_assert();
 		goto error;
 	}