updated mpi_scan macros

diff --git a/lib/auth/dh_common.c b/lib/auth/dh_common.c
index e1985d379c74b2917bed346a66cd4fd8a98b4eb8..3451e8236e991f2650f9d32d6bafc0b782a54046 100644 (file)
--- a/lib/auth/dh_common.c
+++ b/lib/auth/dh_common.c
@@ -71,7 +71,7 @@ _gnutls_proc_dh_common_client_kx(gnutls_session_t session,
        _n_Y = n_Y;
 
        DECR_LEN(data_size, n_Y);
-       if (_gnutls_mpi_scan_nz(&session->key.client_Y, &data[2], _n_Y)) {
+       if (_gnutls_mpi_init_scan_nz(&session->key.client_Y, &data[2], _n_Y)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
@@ -241,17 +241,17 @@ _gnutls_proc_dh_common_server_kx(gnutls_session_t session,
        _n_g = n_g;
        _n_p = n_p;
 
-       if (_gnutls_mpi_scan_nz(&session->key.client_Y, data_Y, _n_Y) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&session->key.client_Y, data_Y, _n_Y) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       if (_gnutls_mpi_scan_nz(&session->key.dh_params.params[DH_G], data_g, _n_g) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&session->key.dh_params.params[DH_G], data_g, _n_g) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       if (_gnutls_mpi_scan_nz(&session->key.dh_params.params[DH_P], data_p, _n_p) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&session->key.dh_params.params[DH_P], data_p, _n_p) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }

diff --git a/lib/auth/srp.c b/lib/auth/srp.c
index c142081aa9745f466c3e2a53264b60130f9492f6..e5a5b1f2dacefc3edae3c08b2b548fb7fc26b4b7 100644 (file)
--- a/lib/auth/srp.c
+++ b/lib/auth/srp.c
@@ -153,21 +153,21 @@ _gnutls_gen_srp_server_kx(gnutls_session_t session,
 
        /* copy from pwd_entry to local variables (actually in session) */
        tmp_size = pwd_entry->g.size;
-       if (_gnutls_mpi_scan_nz(&G, pwd_entry->g.data, tmp_size) < 0) {
+       if (_gnutls_mpi_init_scan_nz(&G, pwd_entry->g.data, tmp_size) < 0) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        tmp_size = pwd_entry->n.size;
-       if (_gnutls_mpi_scan_nz(&N, pwd_entry->n.data, tmp_size) < 0) {
+       if (_gnutls_mpi_init_scan_nz(&N, pwd_entry->n.data, tmp_size) < 0) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        tmp_size = pwd_entry->v.size;
-       if (_gnutls_mpi_scan_nz(&V, pwd_entry->v.data, tmp_size) < 0) {
+       if (_gnutls_mpi_init_scan_nz(&V, pwd_entry->v.data, tmp_size) < 0) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -346,7 +346,7 @@ _gnutls_proc_srp_client_kx(gnutls_session_t session, uint8_t * data,
        _n_A = _gnutls_read_uint16(&data[0]);
 
        DECR_LEN(data_size, _n_A);
-       if (_gnutls_mpi_scan_nz(&A, &data[2], _n_A) || A == NULL) {
+       if (_gnutls_mpi_init_scan_nz(&A, &data[2], _n_A) || A == NULL) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
@@ -889,17 +889,17 @@ _gnutls_proc_srp_server_kx(gnutls_session_t session, uint8_t * data,
        _n_n = n_n;
        _n_b = n_b;
 
-       if (_gnutls_mpi_scan_nz(&N, data_n, _n_n) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&N, data_n, _n_n) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       if (_gnutls_mpi_scan_nz(&G, data_g, _n_g) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&G, data_g, _n_g) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
-       if (_gnutls_mpi_scan_nz(&B, data_b, _n_b) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&B, data_b, _n_b) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
@@ -936,7 +936,7 @@ _gnutls_proc_srp_server_kx(gnutls_session_t session, uint8_t * data,
                return ret;
        }
 
-       if (_gnutls_mpi_scan_nz(&session->key.x, hd, _n_g) != 0) {
+       if (_gnutls_mpi_init_scan_nz(&session->key.x, hd, _n_g) != 0) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }

diff --git a/lib/crypto-backend.h b/lib/crypto-backend.h
index 32c7c3980b9f6781abd46cf18cfbdfbc93f6584b..0b9964c9042d64e6c55c04dde0b13323f68460c6 100644 (file)
--- a/lib/crypto-backend.h
+++ b/lib/crypto-backend.h
@@ -162,7 +162,7 @@ typedef struct gnutls_crypto_bigint {
         * GNUTLS_E_SHORT_MEMORY_BUFFER if buf_size is not sufficient to
         * store this integer, and updates the buf_size;
         */
-        bigint_t(*bigint_scan) (const void *buf, size_t buf_size,
+       int (*bigint_scan) (bigint_t m, const void *buf, size_t buf_size,
                                 gnutls_bigint_format_t format);
        int (*bigint_print) (const bigint_t a, void *buf,
                             size_t * buf_size,

diff --git a/lib/crypto-selftests-pk.c b/lib/crypto-selftests-pk.c
index f00c1d3af34fbba46f500ebe9664660a31fa2fd5..fe4bf1bbc082751be2309cff8586c409e46f939f 100644 (file)
--- a/lib/crypto-selftests-pk.c
+++ b/lib/crypto-selftests-pk.c
@@ -447,25 +447,25 @@ static int test_dh(void)
        
        priv.algo = pub.algo = GNUTLS_PK_DH;
        
-       ret = _gnutls_mpi_scan(&priv.params[DH_P], test_p, sizeof(test_p));
+       ret = _gnutls_mpi_init_scan(&priv.params[DH_P], test_p, sizeof(test_p));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&priv.params[DH_G], test_g, sizeof(test_g));
+       ret = _gnutls_mpi_init_scan(&priv.params[DH_G], test_g, sizeof(test_g));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&priv.params[DH_X], test_x, sizeof(test_x));
+       ret = _gnutls_mpi_init_scan(&priv.params[DH_X], test_x, sizeof(test_x));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&pub.params[DH_Y], test_y, sizeof(test_y));
+       ret = _gnutls_mpi_init_scan(&pub.params[DH_Y], test_y, sizeof(test_y));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
@@ -543,31 +543,31 @@ static int test_ecdh(void)
        
        priv.algo = pub.algo = GNUTLS_PK_EC;
        
-       ret = _gnutls_mpi_scan(&priv.params[ECC_K], test_k, sizeof(test_k));
+       ret = _gnutls_mpi_init_scan(&priv.params[ECC_K], test_k, sizeof(test_k));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&priv.params[ECC_X], test_x, sizeof(test_x));
+       ret = _gnutls_mpi_init_scan(&priv.params[ECC_X], test_x, sizeof(test_x));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&priv.params[ECC_Y], test_y, sizeof(test_y));
+       ret = _gnutls_mpi_init_scan(&priv.params[ECC_Y], test_y, sizeof(test_y));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&pub.params[ECC_X], test_x, sizeof(test_x));
+       ret = _gnutls_mpi_init_scan(&pub.params[ECC_X], test_x, sizeof(test_x));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
        }
 
-       ret = _gnutls_mpi_scan(&pub.params[ECC_Y], test_y, sizeof(test_y));
+       ret = _gnutls_mpi_init_scan(&pub.params[ECC_Y], test_y, sizeof(test_y));
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;

diff --git a/lib/gnutls_dh.c b/lib/gnutls_dh.c
index 7bb3ee02ebd131096c365beebbe29096451406c6..eb706d12d21372b927e1f57ea1ebd90d59e5266a 100644 (file)
--- a/lib/gnutls_dh.c
+++ b/lib/gnutls_dh.c
@@ -103,13 +103,13 @@ gnutls_dh_params_import_raw(gnutls_dh_params_t dh_params,
        size_t siz;
 
        siz = prime->size;
-       if (_gnutls_mpi_scan_nz(&tmp_prime, prime->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&tmp_prime, prime->data, siz)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
        siz = generator->size;
-       if (_gnutls_mpi_scan_nz(&tmp_g, generator->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&tmp_g, generator->data, siz)) {
                _gnutls_mpi_release(&tmp_prime);
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;

diff --git a/lib/gnutls_ecc.c b/lib/gnutls_ecc.c
index 774b5b6d10b524e2af67c9c8f60d8adc7c595dfb..00f7a92d78f8f1db448d86a8864118d201f4d827 100644 (file)
--- a/lib/gnutls_ecc.c
+++ b/lib/gnutls_ecc.c
@@ -92,12 +92,12 @@ _gnutls_ecc_ansi_x963_import(const uint8_t * in,
        }
 
        /* read data */
-       ret = _gnutls_mpi_scan(x, in + 1, (inlen - 1) >> 1);
+       ret = _gnutls_mpi_init_scan(x, in + 1, (inlen - 1) >> 1);
        if (ret < 0)
                return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
 
        ret =
-           _gnutls_mpi_scan(y, in + 1 + ((inlen - 1) >> 1),
+           _gnutls_mpi_init_scan(y, in + 1 + ((inlen - 1) >> 1),
                             (inlen - 1) >> 1);
        if (ret < 0) {
                _gnutls_mpi_release(x);

diff --git a/lib/gnutls_mpi.c b/lib/gnutls_mpi.c
index fc059da303de3dec680dfd0efa116c56aa2ffbe7..c820f7d18e1f6a85f324b656830a9d4ac95b93cc 100644 (file)
--- a/lib/gnutls_mpi.c
+++ b/lib/gnutls_mpi.c
@@ -66,7 +66,7 @@ _gnutls_mpi_random_modp(bigint_t r, bigint_t p,
                goto cleanup;
        }
        
-       ret = _gnutls_mpi_scan(&tmp, buf, size);
+       ret = _gnutls_mpi_init_scan(&tmp, buf, size);
        if (ret < 0) {
                gnutls_assert();
                goto cleanup;
@@ -105,27 +105,36 @@ _gnutls_mpi_random_modp(bigint_t r, bigint_t p,
 
 /* returns %GNUTLS_E_SUCCESS (0) on success
  */
-int _gnutls_mpi_scan(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
+int _gnutls_mpi_init_scan(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 {
-       *ret_mpi =
-           _gnutls_mpi_ops.bigint_scan(buffer, nbytes,
-                                       GNUTLS_MPI_FORMAT_USG);
-       if (*ret_mpi == NULL) {
+bigint_t r;
+int ret;
+
+       ret = _gnutls_mpi_init(&r);
+       if (ret < 0)
+               return gnutls_assert_val(ret);
+
+       ret =
+           _gnutls_mpi_scan(r, buffer, nbytes);
+       if (ret < 0) {
                gnutls_assert();
-               return GNUTLS_E_MPI_SCAN_FAILED;
+               _gnutls_mpi_release(&r);
+               return ret;
        }
 
+       *ret_mpi = r;
+
        return 0;
 }
 
 /* returns %GNUTLS_E_SUCCESS (0) on success. Fails if the number is zero.
  */
 int
-_gnutls_mpi_scan_nz(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
+_gnutls_mpi_init_scan_nz(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 {
        int ret;
 
-       ret = _gnutls_mpi_scan(ret_mpi, buffer, nbytes);
+       ret = _gnutls_mpi_init_scan(ret_mpi, buffer, nbytes);
        if (ret < 0)
                return ret;
 
@@ -140,16 +149,25 @@ _gnutls_mpi_scan_nz(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 }
 
 int
-_gnutls_mpi_scan_pgp(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
+_gnutls_mpi_init_scan_pgp(bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 {
-       *ret_mpi =
-           _gnutls_mpi_ops.bigint_scan(buffer, nbytes,
-                                       GNUTLS_MPI_FORMAT_PGP);
-       if (*ret_mpi == NULL) {
+bigint_t r;
+int ret;
+
+       ret = _gnutls_mpi_init(&r);
+       if (ret < 0)
+               return gnutls_assert_val(ret);
+
+       ret =
+           _gnutls_mpi_scan_pgp(r, buffer, nbytes);
+       if (ret < 0) {
                gnutls_assert();
-               return GNUTLS_E_MPI_SCAN_FAILED;
+               _gnutls_mpi_release(&r);
+               return ret;
        }
 
+       *ret_mpi = r;
+
        return 0;
 }
 
@@ -280,7 +298,7 @@ __gnutls_x509_read_int(ASN1_TYPE node, const char *value,
                return _gnutls_asn2err(result);
        }
 
-       result = _gnutls_mpi_scan(ret_mpi, tmpstr, tmpstr_size);
+       result = _gnutls_mpi_init_scan(ret_mpi, tmpstr, tmpstr_size);
 
        if (overwrite)
                 zeroize_key(tmpstr, tmpstr_size);

diff --git a/lib/gnutls_mpi.h b/lib/gnutls_mpi.h
index 63b2581d4081f7ccabe3f03027cd91d0ecd5db34..23eee6637fd355ff020292b872211713571b9dbe 100644 (file)
--- a/lib/gnutls_mpi.h
+++ b/lib/gnutls_mpi.h
@@ -59,6 +59,8 @@ bigint_t _gnutls_mpi_random_modp(bigint_t, bigint_t p,
 #define _gnutls_mpi_print_lz(x,y,z) _gnutls_mpi_ops.bigint_print(x,y,z,GNUTLS_MPI_FORMAT_STD)
 #define _gnutls_mpi_print_pgp(x,y,z) _gnutls_mpi_ops.bigint_print(x,y,z,GNUTLS_MPI_FORMAT_PGP)
 #define _gnutls_mpi_copy _gnutls_mpi_ops.bigint_copy
+#define _gnutls_mpi_scan(r, b, s) _gnutls_mpi_ops.bigint_scan(r, b, s, GNUTLS_MPI_FORMAT_USG)
+#define _gnutls_mpi_scan_pgp(r, b, s) _gnutls_mpi_ops.bigint_scan(r, b, s, GNUTLS_MPI_FORMAT_PGP)
 
 inline static
 void _gnutls_mpi_release(bigint_t * x)
@@ -70,11 +72,11 @@ void _gnutls_mpi_release(bigint_t * x)
        *x = NULL;
 }
 
-int _gnutls_mpi_scan(bigint_t * ret_mpi, const void *buffer,
+int _gnutls_mpi_init_scan(bigint_t * ret_mpi, const void *buffer,
                     size_t nbytes);
-int _gnutls_mpi_scan_nz(bigint_t * ret_mpi, const void *buffer,
+int _gnutls_mpi_init_scan_nz(bigint_t * ret_mpi, const void *buffer,
                        size_t nbytes);
-int _gnutls_mpi_scan_pgp(bigint_t * ret_mpi, const void *buffer,
+int _gnutls_mpi_init_scan_pgp(bigint_t * ret_mpi, const void *buffer,
                         size_t nbytes);
 
 int _gnutls_mpi_dprint_lz(const bigint_t a, gnutls_datum_t * dest);

diff --git a/lib/gnutls_pubkey.c b/lib/gnutls_pubkey.c
index c16e8a05eb175895da7044b8714fd8b2cff5405f..f8527d9ece29c8b5851892c6d6f51b92424a5038 100644 (file)
--- a/lib/gnutls_pubkey.c
+++ b/lib/gnutls_pubkey.c
@@ -1280,13 +1280,13 @@ gnutls_pubkey_import_rsa_raw(gnutls_pubkey_t key,
        gnutls_pk_params_init(&key->params);
 
        siz = m->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[0], m->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[0], m->data, siz)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
        siz = e->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[1], e->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[1], e->data, siz)) {
                gnutls_assert();
                _gnutls_mpi_release(&key->params.params[0]);
                return GNUTLS_E_MPI_SCAN_FAILED;
@@ -1329,7 +1329,7 @@ gnutls_pubkey_import_ecc_raw(gnutls_pubkey_t key,
 
        key->params.flags = curve;
 
-       if (_gnutls_mpi_scan_nz
+       if (_gnutls_mpi_init_scan_nz
            (&key->params.params[ECC_X], x->data, x->size)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -1337,7 +1337,7 @@ gnutls_pubkey_import_ecc_raw(gnutls_pubkey_t key,
        }
        key->params.params_nr++;
 
-       if (_gnutls_mpi_scan_nz
+       if (_gnutls_mpi_init_scan_nz
            (&key->params.params[ECC_Y], y->data, y->size)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -1440,20 +1440,20 @@ gnutls_pubkey_import_dsa_raw(gnutls_pubkey_t key,
        gnutls_pk_params_init(&key->params);
 
        siz = p->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[0], p->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[0], p->data, siz)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
        siz = q->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[1], q->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[1], q->data, siz)) {
                gnutls_assert();
                _gnutls_mpi_release(&key->params.params[0]);
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
        siz = g->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[2], g->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[2], g->data, siz)) {
                gnutls_assert();
                _gnutls_mpi_release(&key->params.params[1]);
                _gnutls_mpi_release(&key->params.params[0]);
@@ -1461,7 +1461,7 @@ gnutls_pubkey_import_dsa_raw(gnutls_pubkey_t key,
        }
 
        siz = y->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[3], y->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[3], y->data, siz)) {
                gnutls_assert();
                _gnutls_mpi_release(&key->params.params[2]);
                _gnutls_mpi_release(&key->params.params[1]);

diff --git a/lib/gnutls_srp.c b/lib/gnutls_srp.c
index 19b0d7b7badafbaee8592eb1774a15ba7cc2b25c..85185eec5358eff366c9560f339ccdce80701ae8 100644 (file)
--- a/lib/gnutls_srp.c
+++ b/lib/gnutls_srp.c
@@ -48,7 +48,7 @@ _gnutls_srp_gx(uint8_t * text, size_t textsize, uint8_t ** result,
        size_t result_size;
        int ret;
 
-       if (_gnutls_mpi_scan_nz(&x, text, textsize)) {
+       if (_gnutls_mpi_init_scan_nz(&x, text, textsize)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
@@ -174,7 +174,7 @@ bigint_t _gnutls_calc_srp_u(bigint_t A, bigint_t B, bigint_t n)
        /* convert the bytes of hd to integer
         */
        hash_size = 20;         /* SHA */
-       ret = _gnutls_mpi_scan_nz(&res, hd, hash_size);
+       ret = _gnutls_mpi_init_scan_nz(&res, hd, hash_size);
        gnutls_free(holder);
 
        if (ret < 0) {
@@ -631,13 +631,13 @@ gnutls_srp_verifier(const char *username, const char *password,
        }
 
        size = prime->size;
-       if (_gnutls_mpi_scan_nz(&_n, prime->data, size)) {
+       if (_gnutls_mpi_init_scan_nz(&_n, prime->data, size)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }
 
        size = generator->size;
-       if (_gnutls_mpi_scan_nz(&_g, generator->data, size)) {
+       if (_gnutls_mpi_init_scan_nz(&_g, generator->data, size)) {
                gnutls_assert();
                return GNUTLS_E_MPI_SCAN_FAILED;
        }

diff --git a/lib/gnutls_ui.c b/lib/gnutls_ui.c
index 4498c64e6ac25970eb9a8fb125306eaa62670c62..a0b393b3308b1879b88071786264447be2d448c9 100644 (file)
--- a/lib/gnutls_ui.c
+++ b/lib/gnutls_ui.c
@@ -288,7 +288,7 @@ static int mpi_buf2bits(gnutls_datum_t * mpi_buf)
        bigint_t mpi;
        int rc;
 
-       rc = _gnutls_mpi_scan_nz(&mpi, mpi_buf->data, mpi_buf->size);
+       rc = _gnutls_mpi_init_scan_nz(&mpi, mpi_buf->data, mpi_buf->size);
        if (rc) {
                gnutls_assert();
                return rc;

diff --git a/lib/nettle/mpi.c b/lib/nettle/mpi.c
index 5d2818ebddadc9a42b70d6b083b686e572d79bad..db2207ffd61f3bbae07dcf3e5f9b6c38cb3f407f 100644 (file)
--- a/lib/nettle/mpi.c
+++ b/lib/nettle/mpi.c
@@ -141,19 +141,10 @@ fail:
        return GNUTLS_E_MEMORY_ERROR;
 }
 
-static bigint_t
-wrap_nettle_mpi_scan(const void *buffer, size_t nbytes,
+static int
+wrap_nettle_mpi_scan(bigint_t r, const void *buffer, size_t nbytes,
                     gnutls_bigint_format_t format)
 {
-       int ret;
-       bigint_t r;
-       
-       ret = wrap_nettle_mpi_init(&r);
-       if (ret < 0) {
-               gnutls_assert();
-               return NULL;
-       }
-
        if (format == GNUTLS_MPI_FORMAT_USG) {
                nettle_mpz_set_str_256_u(TOMPZ(r), nbytes, buffer);
        } else if (format == GNUTLS_MPI_FORMAT_STD) {
@@ -180,11 +171,9 @@ wrap_nettle_mpi_scan(const void *buffer, size_t nbytes,
                goto fail;
        }
 
-       return r;
-      fail:
-       _gnutls_mpi_release(&r);
-       return NULL;
-
+       return 0;
+ fail:
+       return GNUTLS_E_MPI_SCAN_FAILED;
 }
 
 static int wrap_nettle_mpi_cmp(const bigint_t u, const bigint_t v)

diff --git a/lib/nettle/pk.c b/lib/nettle/pk.c
index 1227c258892d270bf46f202b261b769237d5fa7c..7b92fd8589e99cdd08ca8ac87e83a66b2ce0b573 100644 (file)
--- a/lib/nettle/pk.c
+++ b/lib/nettle/pk.c
@@ -381,7 +381,7 @@ _wrap_nettle_pk_decrypt(gnutls_pk_algorithm_t algo,
                                    gnutls_assert_val
                                    (GNUTLS_E_DECRYPTION_FAILED);
 
-                       if (_gnutls_mpi_scan_nz
+                       if (_gnutls_mpi_init_scan_nz
                            (&c, ciphertext->data,
                             ciphertext->size) != 0) {
                                ret =
@@ -687,7 +687,7 @@ _wrap_nettle_pk_verify(gnutls_pk_algorithm_t algo,
                                    (GNUTLS_E_PK_SIG_VERIFY_FAILED);
 
                        ret =
-                           _gnutls_mpi_scan_nz(&tmp[0], signature->data,
+                           _gnutls_mpi_init_scan_nz(&tmp[0], signature->data,
                                                signature->size);
                        if (ret < 0) {
                                gnutls_assert();

diff --git a/lib/opencdk/read-packet.c b/lib/opencdk/read-packet.c
index 01b50057f917f3df9b553483791e691b57382c45..becd6cb7626e083ef3ccf1162e3b8a29d4138401 100644 (file)
--- a/lib/opencdk/read-packet.c
+++ b/lib/opencdk/read-packet.c
@@ -136,7 +136,7 @@ static cdk_error_t read_mpi(cdk_stream_t inp, bigint_t * ret_m, int secure)
        buf[0] = nbits >> 8;
        buf[1] = nbits >> 0;
        nread += 2;
-       err = _gnutls_mpi_scan_pgp(&m, buf, nread);
+       err = _gnutls_mpi_init_scan_pgp(&m, buf, nread);
        if (err < 0)
                return gnutls_assert_val(map_gnutls_error(err));
 

diff --git a/lib/openpgp/pgp.c b/lib/openpgp/pgp.c
index 0c714e8e4c2694c59881e391e0e2fd68a89d621c..e242da187d41486cb580e22dfb4385a0a121426f 100644 (file)
--- a/lib/openpgp/pgp.c
+++ b/lib/openpgp/pgp.c
@@ -1194,7 +1194,7 @@ _gnutls_read_pgp_mpi(cdk_packet_t pkt, unsigned int priv, size_t idx,
                return _gnutls_map_cdk_rc(err);
        }
 
-       err = _gnutls_mpi_scan(m, buf, buf_size);
+       err = _gnutls_mpi_init_scan(m, buf, buf_size);
        gnutls_free(buf);
 
        if (err < 0) {

diff --git a/lib/x509/crq.c b/lib/x509/crq.c
index 9d91a19d4f7f6a9888917cdcdb0f3635f2afa6f7..98b5e190bd5b066b7dc8e4b65449f752b678eea3 100644 (file)
--- a/lib/x509/crq.c
+++ b/lib/x509/crq.c
@@ -965,14 +965,14 @@ gnutls_x509_crq_set_key_rsa_raw(gnutls_x509_crq_t crq,
        memset(&temp_params, 0, sizeof(temp_params));
 
        siz = m->size;
-       if (_gnutls_mpi_scan_nz(&temp_params.params[0], m->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&temp_params.params[0], m->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto error;
        }
 
        siz = e->size;
-       if (_gnutls_mpi_scan_nz(&temp_params.params[1], e->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&temp_params.params[1], e->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto error;

diff --git a/lib/x509/pkcs12_encr.c b/lib/x509/pkcs12_encr.c
index e194ca48848d31fd11947890fe329f131bc05b43..dac627814e00f804c182b6ab1ffd5f3d23f650aa 100644 (file)
--- a/lib/x509/pkcs12_encr.c
+++ b/lib/x509/pkcs12_encr.c
@@ -96,7 +96,7 @@ _gnutls_pkcs12_string_to_key(unsigned int id, const uint8_t * salt,
                return rc;
        }
 
-       rc = _gnutls_mpi_scan(&mpi512, buf_512, sizeof(buf_512));
+       rc = _gnutls_mpi_init_scan(&mpi512, buf_512, sizeof(buf_512));
        if (rc < 0) {
                gnutls_assert();
                return rc;
@@ -152,7 +152,7 @@ _gnutls_pkcs12_string_to_key(unsigned int id, const uint8_t * salt,
                for (i = 0; i < 64; i++)
                        buf_b[i] = hash[i % 20];
                n = 64;
-               rc = _gnutls_mpi_scan(&num_b1, buf_b, n);
+               rc = _gnutls_mpi_init_scan(&num_b1, buf_b, n);
                if (rc < 0) {
                        gnutls_assert();
                        goto cleanup;
@@ -160,7 +160,7 @@ _gnutls_pkcs12_string_to_key(unsigned int id, const uint8_t * salt,
                _gnutls_mpi_add_ui(num_b1, num_b1, 1);
                for (i = 0; i < 128; i += 64) {
                        n = 64;
-                       rc = _gnutls_mpi_scan(&num_ij, buf_i + i, n);
+                       rc = _gnutls_mpi_init_scan(&num_ij, buf_i + i, n);
                        if (rc < 0) {
                                gnutls_assert();
                                goto cleanup;

diff --git a/lib/x509/privkey.c b/lib/x509/privkey.c
index e31cba82bcc25b1fb0e68e503b847d5655a6fbe4..3739c81bcb4af7fbf9029912ef439bd4e33a6b56 100644 (file)
--- a/lib/x509/privkey.c
+++ b/lib/x509/privkey.c
@@ -745,7 +745,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        gnutls_pk_params_init(&key->params);
 
        siz = m->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[0], m->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[0], m->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -753,7 +753,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        key->params.params_nr++;
 
        siz = e->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[1], e->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[1], e->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -761,7 +761,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        key->params.params_nr++;
 
        siz = d->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[2], d->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[2], d->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -769,7 +769,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        key->params.params_nr++;
 
        siz = p->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[3], p->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[3], p->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -777,7 +777,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        key->params.params_nr++;
 
        siz = q->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[4], q->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[4], q->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -785,7 +785,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
        key->params.params_nr++;
 
        siz = u->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[5], u->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[5], u->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -794,7 +794,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
 
        if (e1 && e2) {
                siz = e1->size;
-               if (_gnutls_mpi_scan_nz
+               if (_gnutls_mpi_init_scan_nz
                    (&key->params.params[6], e1->data, siz)) {
                        gnutls_assert();
                        ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -803,7 +803,7 @@ gnutls_x509_privkey_import_rsa_raw2(gnutls_x509_privkey_t key,
                key->params.params_nr++;
 
                siz = e2->size;
-               if (_gnutls_mpi_scan_nz
+               if (_gnutls_mpi_init_scan_nz
                    (&key->params.params[7], e2->data, siz)) {
                        gnutls_assert();
                        ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -871,35 +871,35 @@ gnutls_x509_privkey_import_dsa_raw(gnutls_x509_privkey_t key,
        }
 
        siz = p->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[0], p->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[0], p->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        siz = q->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[1], q->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[1], q->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        siz = g->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[2], g->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[2], g->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        siz = y->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[3], y->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[3], y->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
        }
 
        siz = x->size;
-       if (_gnutls_mpi_scan_nz(&key->params.params[4], x->data, siz)) {
+       if (_gnutls_mpi_init_scan_nz(&key->params.params[4], x->data, siz)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
                goto cleanup;
@@ -958,7 +958,7 @@ gnutls_x509_privkey_import_ecc_raw(gnutls_x509_privkey_t key,
 
        key->params.flags = curve;
 
-       if (_gnutls_mpi_scan_nz
+       if (_gnutls_mpi_init_scan_nz
            (&key->params.params[ECC_X], x->data, x->size)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -966,7 +966,7 @@ gnutls_x509_privkey_import_ecc_raw(gnutls_x509_privkey_t key,
        }
        key->params.params_nr++;
 
-       if (_gnutls_mpi_scan_nz
+       if (_gnutls_mpi_init_scan_nz
            (&key->params.params[ECC_Y], y->data, y->size)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;
@@ -974,7 +974,7 @@ gnutls_x509_privkey_import_ecc_raw(gnutls_x509_privkey_t key,
        }
        key->params.params_nr++;
 
-       if (_gnutls_mpi_scan_nz
+       if (_gnutls_mpi_init_scan_nz
            (&key->params.params[ECC_K], k->data, k->size)) {
                gnutls_assert();
                ret = GNUTLS_E_MPI_SCAN_FAILED;