Updated _gnutls_mpi_init prototype and added _gnutls_mpi_init_multi

diff --git a/lib/auth/srp.c b/lib/auth/srp.c
index 702b94052c34518521622ea0e42c597028d76e3b..3966b0b9b241fe6f4d55a566759bd83971ffcdae 100644 (file)
--- 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 a497f5614628edfa762ab9d14dae772df29c7260..25fdeb07e35659f55bb9e88bbe329ceb0225607a 100644 (file)
--- 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 f0a20790d37edb24e833c0bdf03ea534e5a82499..3d59e464f9752d5ec018ea145d6345daebf2e665 100644 (file)
--- 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 8b26afc94515d08edec107bc2cdd9ccefca9c719..19b0d7b7badafbaee8592eb1774a15ba7cc2b25c 100644 (file)
--- 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 034c74edf395431646bf316249b5d6d3c761ef68..c4645ac1f5e805de88227e54a41cce8d2d55604b 100644 (file)
--- 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 adf63535774e6dc85547a859806f87b848a28c1e..72407fa37b14fef74b1cc61fbab7754decc3a983 100644 (file)
--- 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 9b91ba9ea870649099f17f1f1df4a90e52557c80..accf4ae411e5df09b5e09d9e36e836ad26b7a49d 100644 (file)
--- 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;
        }