first changes for libgmp supportgnutls_0_4_with_nettle

21 files changed, 176 insertions, 171 deletions

diff --git a/lib/auth_anon.c b/lib/auth_anon.c
index d343ec129a..663c2ee42f 100644
--- a/lib/auth_anon.c
+++ b/lib/auth_anon.c
@@ -57,7 +57,7 @@ MOD_AUTH_STRUCT anon_auth_struct = {
 };
 
 int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
-	MPI x, X, g, p;
+	GNUTLS_MPI x, X, g, p;
 	int bits, ret;
 	size_t n_X, n_g, n_p;
 	uint8 *data_p;
@@ -86,7 +86,7 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
 	}
 
 	info = _gnutls_get_auth_info( state);	
-	if ((ret=_gnutls_dh_set_prime_bits( state, gcry_mpi_get_nbits(p))) < 0) {
+	if ((ret=_gnutls_dh_set_prime_bits( state, _gnutls_mpi_get_nbits(p))) < 0) {
 		gnutls_assert();
 		return ret;
 	}
@@ -100,7 +100,7 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
 		_gnutls_mpi_release( &X);
 		return GNUTLS_E_MEMORY_ERROR;
 	}
-	ret=_gnutls_dh_set_secret_bits( state, gcry_mpi_get_nbits(x));
+	ret=_gnutls_dh_set_secret_bits( state, _gnutls_mpi_get_nbits(x));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
@@ -139,7 +139,7 @@ int gen_anon_server_kx( GNUTLS_STATE state, opaque** data) {
 }
 
 int gen_anon_client_kx( GNUTLS_STATE state, opaque** data) {
-MPI x, X;
+GNUTLS_MPI x, X;
 size_t n_X;
 int ret;
 
@@ -151,7 +151,7 @@ int ret;
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 	
-	ret=_gnutls_dh_set_secret_bits( state, gcry_mpi_get_nbits(x));
+	ret=_gnutls_dh_set_secret_bits( state, _gnutls_mpi_get_nbits(x));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
@@ -249,21 +249,21 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 		return ret;
 	}
 
-	if ( gcry_mpi_get_nbits( state->gnutls_key->client_p) < _gnutls_dh_get_prime_bits( state)) {
+	if ( _gnutls_mpi_get_nbits( state->gnutls_key->client_p) < _gnutls_dh_get_prime_bits( state)) {
 		/* the prime used by the peer is not acceptable
 		 */
 		gnutls_assert();
 		return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
 	}
 	
-	ret=_gnutls_dh_set_prime_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_prime_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_p));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
 	}
 
-	ret=_gnutls_dh_set_peer_public_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_peer_public_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_Y));
 	if (ret<0) {
 		gnutls_assert();
@@ -277,7 +277,7 @@ int proc_anon_server_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 int proc_anon_client_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 	uint16 n_Y;
 	size_t _n_Y;
-	MPI g, p;
+	GNUTLS_MPI g, p;
 	int bits, ret;
 	const GNUTLS_ANON_SERVER_CREDENTIALS cred;
 	
@@ -305,7 +305,7 @@ int proc_anon_client_kx( GNUTLS_STATE state, opaque* data, int data_size) {
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	ret=_gnutls_dh_set_peer_public_bits( state, gcry_mpi_get_nbits(state->gnutls_key->client_Y));
+	ret=_gnutls_dh_set_peer_public_bits( state, _gnutls_mpi_get_nbits(state->gnutls_key->client_Y));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
diff --git a/lib/auth_dhe.c b/lib/auth_dhe.c
index 3ccb935194..c0de5a8d01 100644
--- a/lib/auth_dhe.c
+++ b/lib/auth_dhe.c
@@ -80,7 +80,7 @@ MOD_AUTH_STRUCT dhe_dss_auth_struct = {
 
 static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 {
-	MPI x, X, g, p;
+	GNUTLS_MPI x, X, g, p;
 	size_t n_X, n_g, n_p;
 	uint8 *data_p;
 	uint8 *data_g;
@@ -123,7 +123,7 @@ static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 	}
 
 	info = _gnutls_get_auth_info( state);
-	ret=_gnutls_dh_set_prime_bits( state, gcry_mpi_get_nbits(p));
+	ret=_gnutls_dh_set_prime_bits( state, _gnutls_mpi_get_nbits(p));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
@@ -137,7 +137,7 @@ static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 	state->gnutls_key->dh_secret = x;
-	ret=_gnutls_dh_set_secret_bits( state, gcry_mpi_get_nbits(x));
+	ret=_gnutls_dh_set_secret_bits( state, _gnutls_mpi_get_nbits(x));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
@@ -212,7 +212,7 @@ static int gen_dhe_server_kx(GNUTLS_STATE state, opaque ** data)
 
 static int gen_dhe_client_kx(GNUTLS_STATE state, opaque ** data)
 {
-	MPI x, X;
+	GNUTLS_MPI x, X;
 	size_t n_X;
 	int ret;
 
@@ -225,7 +225,7 @@ static int gen_dhe_client_kx(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	ret=_gnutls_dh_set_secret_bits( state, gcry_mpi_get_nbits(x));
+	ret=_gnutls_dh_set_secret_bits( state, _gnutls_mpi_get_nbits(x));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
@@ -255,7 +255,7 @@ static int gen_dhe_client_kx(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	ret=_gnutls_dh_set_peer_public_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_peer_public_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_Y));
 	if (ret<0) {
 		gnutls_assert();
@@ -350,21 +350,21 @@ static int proc_dhe_server_kx(GNUTLS_STATE state, opaque * data,
 		return GNUTLS_E_MPI_SCAN_FAILED;
 	}
 
-	ret=_gnutls_dh_set_peer_public_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_peer_public_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_Y));
 	if (ret<0) {
 		gnutls_assert();
 		return ret;
 	}
 
-	if ( gcry_mpi_get_nbits( state->gnutls_key->client_p) < _gnutls_dh_get_prime_bits( state)) {
+	if ( _gnutls_mpi_get_nbits( state->gnutls_key->client_p) < _gnutls_dh_get_prime_bits( state)) {
 		/* the prime used by the peer is not acceptable
 		 */
 		gnutls_assert();
 		return GNUTLS_E_DH_PRIME_UNACCEPTABLE;
 	}
 
-	ret=_gnutls_dh_set_prime_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_prime_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_p));
 	if (ret<0) {
 		gnutls_assert();
@@ -426,7 +426,7 @@ static int proc_dhe_client_kx(GNUTLS_STATE state, opaque * data,
 {
 	uint16 n_Y;
 	size_t _n_Y;
-	MPI g, p;
+	GNUTLS_MPI g, p;
 	int bits, ret;
 	const GNUTLS_CERTIFICATE_CREDENTIALS cred;
 
@@ -448,7 +448,7 @@ static int proc_dhe_client_kx(GNUTLS_STATE state, opaque * data,
 		return GNUTLS_E_MPI_SCAN_FAILED;
 	}
 
-	ret=_gnutls_dh_set_peer_public_bits( state, gcry_mpi_get_nbits(
+	ret=_gnutls_dh_set_peer_public_bits( state, _gnutls_mpi_get_nbits(
 		state->gnutls_key->client_Y));
 	if (ret<0) {
 		gnutls_assert();
diff --git a/lib/auth_rsa.c b/lib/auth_rsa.c
index 8c1c65c59a..d029957909 100644
--- a/lib/auth_rsa.c
+++ b/lib/auth_rsa.c
@@ -66,7 +66,7 @@ MOD_AUTH_STRUCT rsa_auth_struct = {
 
 /* This function reads the RSA parameters from peer's certificate;
  */
-static int _gnutls_get_public_rsa_params(GNUTLS_STATE state, MPI params[MAX_PARAMS_SIZE], int* params_len)
+static int _gnutls_get_public_rsa_params(GNUTLS_STATE state, GNUTLS_MPI params[MAX_PARAMS_SIZE], int* params_len)
 {
 int ret;
 CERTIFICATE_AUTH_INFO info = _gnutls_get_auth_info( state);
@@ -108,7 +108,7 @@ int i;
 	*params_len = peer_cert.params_size;
 
 	for (i=0;i<*params_len;i++) {
-		params[i] = gcry_mpi_copy(peer_cert.params[i]);
+		params[i] = _gnutls_mpi_copy(peer_cert.params[i]);
 	}
 	_gnutls_free_cert( peer_cert);
 
@@ -117,7 +117,7 @@ int i;
 
 /* This function reads the RSA parameters from the private key
  */
-static int _gnutls_get_private_rsa_params(GNUTLS_STATE state, MPI **params, int* params_size)
+static int _gnutls_get_private_rsa_params(GNUTLS_STATE state, GNUTLS_MPI **params, int* params_size)
 {
 int index;
 const GNUTLS_CERTIFICATE_CREDENTIALS cred;
@@ -153,7 +153,7 @@ int proc_rsa_client_kx(GNUTLS_STATE state, opaque * data, int data_size)
 	gnutls_sdatum plaintext;
 	gnutls_datum ciphertext;
 	int ret, dsize;
-	MPI *params;
+	GNUTLS_MPI *params;
 	int params_len;
 
 	if (gnutls_protocol_get_version(state) == GNUTLS_SSL3) {
@@ -218,7 +218,7 @@ int gen_rsa_client_kx(GNUTLS_STATE state, opaque ** data)
 {
 	CERTIFICATE_AUTH_INFO auth = state->gnutls_key->auth_info;
 	gnutls_datum sdata;	/* data to send */
-	MPI params[MAX_PARAMS_SIZE];
+	GNUTLS_MPI params[MAX_PARAMS_SIZE];
 	int params_len = MAX_PARAMS_SIZE;
 	int ret, i;
 	GNUTLS_Version ver;
diff --git a/lib/auth_srp.c b/lib/auth_srp.c
index eb8e217f55..d570d8b2ab 100644
--- a/lib/auth_srp.c
+++ b/lib/auth_srp.c
@@ -124,9 +124,9 @@ int gen_srp_server_hello(GNUTLS_STATE state, opaque ** data)
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	gcry_mpi_set(G, pwd_entry->g);
-	gcry_mpi_set(N, pwd_entry->n);
-	gcry_mpi_set(V, pwd_entry->v);
+	_gnutls_mpi_set(G, pwd_entry->g);
+	_gnutls_mpi_set(N, pwd_entry->n);
+	_gnutls_mpi_set(V, pwd_entry->v);
 
 	(*data) = gnutls_malloc(n_n + n_g + pwd_entry->salt_size + 6 + 1);
 	if ((*data)==NULL) {
diff --git a/lib/auth_srp_passwd.c b/lib/auth_srp_passwd.c
index 97fe1ce207..b289293246 100644
--- a/lib/auth_srp_passwd.c
+++ b/lib/auth_srp_passwd.c
@@ -344,7 +344,7 @@ GNUTLS_SRP_PWD_ENTRY* _gnutls_randomize_pwd_entry() {
 		return NULL;
 	}
 
-        gcry_mpi_randomize( pwd_entry->v, 160, GCRY_WEAK_RANDOM);
+        _gnutls_mpi_randomize( pwd_entry->v, 160, GCRY_WEAK_RANDOM);
 
 	pwd_entry->salt_size = RND_SALT_SIZE;
 	
@@ -385,7 +385,7 @@ void _gnutls_srp_clear_pwd_entry( GNUTLS_SRP_PWD_ENTRY * entry) {
 int _gnutls_srp_generate_prime(opaque ** ret_g, opaque ** ret_n, int bits)
 {
 
-	MPI prime, g;
+	GNUTLS_MPI prime, g;
 	int siz;
 	char *tmp;
 
diff --git a/lib/crypt.c b/lib/crypt.c
index 9e4c00c03b..6da9c339b5 100644
--- a/lib/crypt.c
+++ b/lib/crypt.c
@@ -26,7 +26,7 @@
 #include "crypt_srpsha1.h"
 #include "gnutls_random.h"
 
-char * gnutls_crypt(const char* username, const char *passwd, crypt_algo algo, int salt, MPI g, MPI n) {
+char * gnutls_crypt(const char* username, const char *passwd, crypt_algo algo, int salt, GNUTLS_MPI g, GNUTLS_MPI n) {
 	
 	switch(algo) {
 	case BLOWFISH_CRYPT: /* bcrypt */
@@ -39,7 +39,7 @@ char * gnutls_crypt(const char* username, const char *passwd, crypt_algo algo, i
 	return NULL;
 }
 
-int gnutls_crypt_vrfy(const char* username, const char *passwd, char* salt, MPI g, MPI n) {
+int gnutls_crypt_vrfy(const char* username, const char *passwd, char* salt, GNUTLS_MPI g, GNUTLS_MPI n) {
 	char* cr;
 
 	switch(salt[0]) {
diff --git a/lib/crypt_bcrypt.c b/lib/crypt_bcrypt.c
index a9c9aa8fa3..55ece44c4b 100644
--- a/lib/crypt_bcrypt.c
+++ b/lib/crypt_bcrypt.c
@@ -600,7 +600,7 @@ static const char magic[] = "$2$";
 
 #define B64TEXT "OrpheanBeholderScryDoubt"
 
-char *crypt_bcrypt(const char* username, const char *passwd, const char *salt, MPI g, MPI n)
+char *crypt_bcrypt(const char* username, const char *passwd, const char *salt, GNUTLS_MPI g, GNUTLS_MPI n)
 {
 	unsigned char *sp;
 	blf_ctx *ctx;
@@ -695,7 +695,7 @@ char *crypt_bcrypt(const char* username, const char *passwd, const char *salt, M
 /* cost is stored as the first byte in salt (thus < 255) which is 
  * just fine! 
  */
-char *crypt_bcrypt_wrapper(const char* username, const char *pass_new, int cost, MPI g, MPI n)
+char *crypt_bcrypt_wrapper(const char* username, const char *pass_new, int cost, GNUTLS_MPI g, GNUTLS_MPI n)
 {
 	opaque *result;
 	char *tcp;
diff --git a/lib/crypt_srpsha1.c b/lib/crypt_srpsha1.c
index f58cdbe87d..0dbc5ff8e8 100644
--- a/lib/crypt_srpsha1.c
+++ b/lib/crypt_srpsha1.c
@@ -33,7 +33,7 @@
 static const char magic[] = "";
 
 char *crypt_srpsha1(const char *username, const char *passwd,
-		    const char *salt, MPI g, MPI n)
+		    const char *salt, GNUTLS_MPI g, GNUTLS_MPI n)
 {
 	unsigned char *sp, r1[MAX_HASH_SIZE];
 	int salt_size = strlen(salt);
@@ -130,7 +130,7 @@ char *crypt_srpsha1(const char *username, const char *passwd,
 
 /* salt here is the salt size */
 char *crypt_srpsha1_wrapper(const char *username, const char *pass_new,
-			    int salt, MPI g, MPI n)
+			    int salt, GNUTLS_MPI g, GNUTLS_MPI n)
 {
 	unsigned char *result;
 	char *tcp;
diff --git a/lib/debug.c b/lib/debug.c
index 870cc0230d..405a4f5099 100644
--- a/lib/debug.c
+++ b/lib/debug.c
@@ -25,14 +25,14 @@
 
 #ifdef DEBUG
 
-void _gnutls_dump_mpi(char* prefix, MPI a)
+void _gnutls_dump_mpi(char* prefix, GNUTLS_MPI a)
 {
 	char buf[400];
 	size_t n = sizeof buf;
 	
-	if (gcry_mpi_print(GCRYMPI_FMT_HEX, buf, &n, a))
+	if (gcry_mpi_print(GCRYGNUTLS_MPI_FMT_HEX, buf, &n, a))
 		strcpy(buf, "[can't print value]"); /* Flawfinder: ignore */
-	_gnutls_log( "MPI: length: %d\n\t%s%s\n", (n-1)/2, prefix, buf);
+	_gnutls_log( "GNUTLS_MPI: length: %d\n\t%s%s\n", (n-1)/2, prefix, buf);
 }
 
 
diff --git a/lib/gnutls_auth.c b/lib/gnutls_auth.c
index 48636ef5fe..864a214163 100644
--- a/lib/gnutls_auth.c
+++ b/lib/gnutls_auth.c
@@ -282,7 +282,7 @@ int _gnutls_auth_info_set( GNUTLS_STATE state, CredType type, int size, int allo
 	return 0;
 }
 
-/* this function will copy an MPI key to 
+/* this function will copy an GNUTLS_MPI key to 
  * opaque data.
  */
 int _gnutls_generate_key(GNUTLS_KEY key) {
diff --git a/lib/gnutls_dh.c b/lib/gnutls_dh.c
index ee2508f276..784ed4c554 100644
--- a/lib/gnutls_dh.c
+++ b/lib/gnutls_dh.c
@@ -57,10 +57,10 @@ static int get_x_size(int bits)
 
 /* returns the public value (X), and the secret (ret_x).
  */
-MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
+GNUTLS_MPI gnutls_calc_dh_secret(GNUTLS_MPI * ret_x, GNUTLS_MPI g, GNUTLS_MPI prime)
 {
-	MPI e, x;
-	int x_size = get_x_size(gcry_mpi_get_nbits(prime));
+	GNUTLS_MPI e, x;
+	int x_size = get_x_size(_gnutls_mpi_get_nbits(prime));
 
 
 	x = _gnutls_mpi_new(x_size);	/* FIXME: allocate in secure memory */
@@ -72,7 +72,7 @@ MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
 		return NULL;
 	}
 
-	gcry_mpi_randomize(x, x_size, GCRY_STRONG_RANDOM);
+	_gnutls_mpi_randomize(x, x_size, GCRY_STRONG_RANDOM);
 	/* fixme: set high bit of x and select a larger one */
 
 	e = _gnutls_mpi_alloc_like(prime);
@@ -84,7 +84,7 @@ MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
 		_gnutls_mpi_release( &x);
 		return NULL;
 	}
-	gcry_mpi_powm(e, g, x, prime);
+	_gnutls_mpi_powm(e, g, x, prime);
 
 	if (ret_x)
 		*ret_x = x;
@@ -94,14 +94,14 @@ MPI gnutls_calc_dh_secret(MPI * ret_x, MPI g, MPI prime)
 }
 
 
-MPI gnutls_calc_dh_key(MPI f, MPI x, MPI prime)
+GNUTLS_MPI gnutls_calc_dh_key(GNUTLS_MPI f, GNUTLS_MPI x, GNUTLS_MPI prime)
 {
-	MPI k;
+	GNUTLS_MPI k;
 
 	k = _gnutls_mpi_alloc_like(prime);
 	if (k == NULL)
 		return NULL;
-	gcry_mpi_powm(k, f, x, prime);
+	_gnutls_mpi_powm(k, f, x, prime);
 	return k;
 }
 
diff --git a/lib/gnutls_dh_primes.c b/lib/gnutls_dh_primes.c
index 4eb0bf643b..47bad3ade9 100644
--- a/lib/gnutls_dh_primes.c
+++ b/lib/gnutls_dh_primes.c
@@ -223,7 +223,7 @@ static uint8 diffie_hellman_prime_2048[] = { 0x00,
 };
 
 /* Holds the prime to be used in DH authentication.
- * Initialy the MPIs are not calculated (must call global_init, or _gnutls_dh_calc_mpis()).
+ * Initialy the GNUTLS_MPIs are not calculated (must call global_init, or _gnutls_dh_calc_mpis()).
  */
 _GNUTLS_DH_PARAMS _gnutls_dh_default_params[] = {
 	{768, NULL, NULL, {DH_G_1024, sizeof(DH_G_1024)}
@@ -301,7 +301,7 @@ static int normalize_bits(int bits)
 	return bits;
 }
 
-/* Clears allocated MPIs and data. Only to be called at exit.
+/* Clears allocated GNUTLS_MPIs and data. Only to be called at exit.
  */
 void _gnutls_dh_clear_mpis(void) {
 int i;
@@ -321,7 +321,7 @@ int i;
 
 }
 
-/* Generates MPIs from opaque integer data. Initializes the dh_primes to
+/* Generates GNUTLS_MPIs from opaque integer data. Initializes the dh_primes to
  * be used.
  */
 int _gnutls_dh_calc_mpis(void)
@@ -363,9 +363,9 @@ int i, n;
 /* returns g and p, depends on the requested bits.
  * We only support limited key sizes.
  */
-MPI gnutls_get_dh_params(GNUTLS_DH_PARAMS dh_primes, MPI * ret_p, int bits)
+GNUTLS_MPI gnutls_get_dh_params(GNUTLS_DH_PARAMS dh_primes, GNUTLS_MPI * ret_p, int bits)
 {
-	MPI g=NULL, prime=NULL;
+	GNUTLS_MPI g=NULL, prime=NULL;
 	int i;
 
 	if (dh_primes==NULL) {
@@ -378,8 +378,8 @@ MPI gnutls_get_dh_params(GNUTLS_DH_PARAMS dh_primes, MPI * ret_p, int bits)
 	i = 0;
 	do {
 		if (dh_primes[i].bits == bits) {
-			prime = gcry_mpi_copy(dh_primes[i]._prime);
-			g = gcry_mpi_copy(dh_primes[i]._generator);
+			prime = _gnutls_mpi_copy(dh_primes[i]._prime);
+			g = _gnutls_mpi_copy(dh_primes[i]._generator);
 			break;
 		}
 		i++;
@@ -401,9 +401,9 @@ MPI gnutls_get_dh_params(GNUTLS_DH_PARAMS dh_primes, MPI * ret_p, int bits)
 /* returns g and p, depends on the requested bits.
  * We only support limited key sizes.
  */
-MPI _gnutls_get_rnd_srp_params( MPI * ret_p, int bits)
+GNUTLS_MPI _gnutls_get_rnd_srp_params( GNUTLS_MPI * ret_p, int bits)
 {
-	MPI g=NULL, prime=NULL;
+	GNUTLS_MPI g=NULL, prime=NULL;
 	int i;
 
 	if (_gnutls_dh_default_params==NULL) {
@@ -416,8 +416,8 @@ MPI _gnutls_get_rnd_srp_params( MPI * ret_p, int bits)
 	i = 0;
 	do {
 		if (_gnutls_dh_default_params[i].bits == bits) {
-			prime = gcry_mpi_copy(_gnutls_dh_default_params[i]._prime);
-			g = gcry_mpi_copy(_gnutls_dh_default_params[i]._generator);
+			prime = _gnutls_mpi_copy(_gnutls_dh_default_params[i]._prime);
+			g = _gnutls_mpi_copy(_gnutls_dh_default_params[i]._generator);
 			break;
 		}
 		i++;
@@ -437,13 +437,13 @@ MPI _gnutls_get_rnd_srp_params( MPI * ret_p, int bits)
 }
 
 /* These should be added in gcrypt.h */
-MPI _gcry_generate_elg_prime(int mode, unsigned pbits,
-			     unsigned qbits, MPI g, MPI ** ret_factors);
+GNUTLS_MPI _gcry_generate_elg_prime(int mode, unsigned pbits,
+			     unsigned qbits, GNUTLS_MPI g, GNUTLS_MPI ** ret_factors);
 
-int _gnutls_dh_generate_prime(MPI * ret_g, MPI * ret_n, int bits)
+int _gnutls_dh_generate_prime(GNUTLS_MPI * ret_g, GNUTLS_MPI * ret_n, int bits)
 {
 
-	MPI g, prime;
+	GNUTLS_MPI g, prime;
 	int qbits;
 
 	g = mpi_new(16);	/* this should be ok */
@@ -509,7 +509,7 @@ int i=0;
   **/
 int gnutls_dh_params_set( GNUTLS_DH_PARAMS dh_params, gnutls_datum prime, gnutls_datum generator, int bits)
 {
-	MPI tmp_prime, tmp_g;
+	GNUTLS_MPI tmp_prime, tmp_g;
 	int siz=0, i=0;
 	GNUTLS_DH_PARAMS sprime;
 
@@ -551,8 +551,8 @@ int gnutls_dh_params_set( GNUTLS_DH_PARAMS dh_params, gnutls_datum prime, gnutls
 	sprime->_prime = tmp_prime;
 	sprime->_generator = tmp_g;
 
-/*	sprime->_prime = gcry_mpi_copy(tmp_prime);
-	sprime->_generator = gcry_mpi_copy(tmp_g);
+/*	sprime->_prime = _gnutls_mpi_copy(tmp_prime);
+	sprime->_generator = _gnutls_mpi_copy(tmp_g);
 */
 	if (gnutls_set_datum( &sprime->prime, prime.data, prime.size) < 0) {
 		gnutls_assert();
@@ -641,7 +641,7 @@ int i;
 int gnutls_dh_params_generate( gnutls_datum* prime, gnutls_datum* generator, int bits)
 {
 
-	MPI tmp_prime, tmp_g;
+	GNUTLS_MPI tmp_prime, tmp_g;
 	int siz;
 
 	if (check_bits(bits) < 0) {
diff --git a/lib/gnutls_gcry.c b/lib/gnutls_gcry.c
index 7827058839..a18908ea66 100644
--- a/lib/gnutls_gcry.c
+++ b/lib/gnutls_gcry.c
@@ -25,27 +25,26 @@
 /* Functions that refer to the libgcrypt library.
  */
  
-void _gnutls_mpi_release( MPI* x) {
+void _gnutls_mpi_release( GNUTLS_MPI* x) {
 	if (*x==NULL) return;
 	gcry_mpi_release(*x);
 	*x=NULL;
 }
 
-MPI _gnutls_mpi_new( int bits) {
-	return gcry_mpi_new( bits);
-}
-
-int _gnutls_mpi_scan( GCRY_MPI *ret_mpi, const opaque *buffer, size_t *nbytes ) {
+int _gnutls_mpi_scan( GNUTLS_MPI *ret_mpi, const opaque *buffer, size_t *nbytes ) {
 	return gcry_mpi_scan( ret_mpi, GCRYMPI_FMT_USG, buffer, nbytes);
+}
 
+int _gnutls_mpi_scan_pgp( GNUTLS_MPI *ret_mpi, const opaque *buffer, size_t *nbytes ) {
+	return gcry_mpi_scan( ret_mpi, GCRYMPI_FMT_PGP, buffer, nbytes);
 }
 
-int _gnutls_mpi_print( opaque *buffer, size_t *nbytes, const GCRY_MPI a ) {
+int _gnutls_mpi_print( opaque *buffer, size_t *nbytes, const GNUTLS_MPI a ) {
 	return gcry_mpi_print( GCRYMPI_FMT_USG, buffer, nbytes, a);
 }
 
 /* Always has the first bit zero */
-int _gnutls_mpi_print_lz( opaque *buffer, size_t *nbytes, const GCRY_MPI a ) {
+int _gnutls_mpi_print_lz( opaque *buffer, size_t *nbytes, const GNUTLS_MPI a ) {
 	return gcry_mpi_print( GCRYMPI_FMT_STD, buffer, nbytes, a);
 }
 
@@ -54,7 +53,7 @@ int _gnutls_mpi_print_lz( opaque *buffer, size_t *nbytes, const GCRY_MPI a ) {
  * from asn1 structs. Combines the read and mpi_scan
  * steps.
  */
-int _gnutls_x509_read_int( node_asn* node, char* value, char* tmpstr, int tmpstr_size, MPI* ret_mpi) {
+int _gnutls_x509_read_int( node_asn* node, char* value, char* tmpstr, int tmpstr_size, GNUTLS_MPI* ret_mpi) {
 int len, result;
 
 	len = tmpstr_size - 1;
diff --git a/lib/gnutls_gcry.h b/lib/gnutls_gcry.h
index e9836f29b3..2248951a52 100644
--- a/lib/gnutls_gcry.h
+++ b/lib/gnutls_gcry.h
@@ -4,16 +4,32 @@
 # include <gcrypt.h>
 # include <x509_asn1.h>
 
-MPI _gnutls_mpi_new( int);
-
-# define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(gcry_mpi_get_nbits(x)) 
+#define GNUTLS_MPI GCRY_MPI
+
+#define _gnutls_mpi_new gcry_mpi_new
+#define _gnutls_mpi_snew gcry_mpi_snew
+#define _gnutls_mpi_copy gcry_mpi_copy
+#define _gnutls_mpi_set_ui gcry_mpi_set_ui
+#define _gnutls_mpi_set gcry_mpi_set
+#define _gnutls_mpi_randomize gcry_mpi_randomize
+#define _gnutls_mpi_get_nbits gcry_mpi_get_nbits
+#define _gnutls_mpi_powm gcry_mpi_powm
+#define _gnutls_mpi_invm _gcry_mpi_invm
+#define _gnutls_mpi_addm gcry_mpi_addm
+#define _gnutls_mpi_subm gcry_mpi_subm
+#define _gnutls_mpi_mulm gcry_mpi_mulm
+#define _gnutls_mpi_mul gcry_mpi_mul
+#define _gnutls_mpi_add gcry_mpi_add
+
+# define _gnutls_mpi_alloc_like(x) _gnutls_mpi_new(_gnutls_mpi_get_nbits(x)) 
 
 void _gnutls_mpi_release( MPI* x);
 
-int _gnutls_mpi_scan( GCRY_MPI *ret_mpi, const opaque *buffer, size_t *nbytes );
+int _gnutls_mpi_scan( GNUTLS_MPI *ret_mpi, const opaque *buffer, size_t *nbytes );
+int _gnutls_mpi_scan_pgp( GNUTLS_MPI *ret_mpi, const opaque *buffer, size_t *nbytes );
 
-int _gnutls_mpi_print( opaque *buffer, size_t *nbytes, const GCRY_MPI a );
-int _gnutls_mpi_print_lz( opaque *buffer, size_t *nbytes, const GCRY_MPI a );
+int _gnutls_mpi_print( opaque *buffer, size_t *nbytes, const GNUTLS_MPI a );
+int _gnutls_mpi_print_lz( opaque *buffer, size_t *nbytes, const GNUTLS_MPI a );
 
 int _gnutls_x509_read_int( node_asn* node, char* value, char* tmpstr, int tmpstr_size, MPI* ret_mpi);
 
diff --git a/lib/gnutls_openpgp.c b/lib/gnutls_openpgp.c
index ba22bbab59..8d2835a9cf 100644
--- a/lib/gnutls_openpgp.c
+++ b/lib/gnutls_openpgp.c
@@ -43,15 +43,14 @@
 #define OPENPGP_NAME_SIZE GNUTLS_X509_CN_SIZE
 
 static void
-release_mpi_array(MPI *arr, size_t n)
+release_mpi_array(GNUTLS_MPI *arr, size_t n)
 {
-  MPI x;
+  GNUTLS_MPI x;
   
   while (arr && n--)
     {
       x = *arr;
-      /*_gnutls_mpi_release(&x);*/
-      gcry_mpi_release(x);
+      _gnutls_mpi_release(&x);
       *arr = NULL; arr++;
     }
 }
@@ -380,7 +379,7 @@ openpgp_pk_to_gnutls_cert(gnutls_cert *cert, PKT_public_key *pk)
   for (i=0; i<cert->params_size; i++)
     {      
       nbytes = pk->mpi[i].bytes+2;
-      rc = gcry_mpi_scan(&cert->params[i], GCRYMPI_FMT_PGP,
+      rc = _gnutls_mpi_scan_pgp(&cert->params[i], 
                          pk->mpi[i].data, &nbytes);
       if (rc)
         {
@@ -484,7 +483,7 @@ _gnutls_openpgp_key2gnutls_key( gnutls_private_key *pkey,
   for (i=0; i<pkey->params_size; i++)
     {
       nbytes = sk->pk->mpi[i].bytes+2;
-      rc = gcry_mpi_scan(&pkey->params[i], GCRYMPI_FMT_PGP,
+      rc = _gnutls_mpi_scan_pgp(&pkey->params[i],
                          sk->pk->mpi[i].data, &nbytes);
       if (rc)
         {
@@ -497,7 +496,7 @@ _gnutls_openpgp_key2gnutls_key( gnutls_private_key *pkey,
   for (j=0; j<cdk_pk_get_nskey( pke_algo ); j++, i++)
     {
       nbytes = sk->mpi[j]->bytes+2;
-      rc = gcry_mpi_scan(&pkey->params[i], GCRYMPI_FMT_PGP,
+      rc = _gnutls_mpi_scan_pgp(&pkey->params[i],
                          sk->mpi[j]->data, &nbytes);
       if (rc)
         {
diff --git a/lib/gnutls_openpgp.h b/lib/gnutls_openpgp.h
index a729aa48a0..8149556f3e 100644
--- a/lib/gnutls_openpgp.h
+++ b/lib/gnutls_openpgp.h
@@ -69,12 +69,3 @@ _gnutls_openpgp_request_key( gnutls_datum* ret,
 	int key_fpr_size);
 
 #endif /*GNUTLS_OPENPGP_H*/
-
-
-
-
-
-
-
-
-
diff --git a/lib/gnutls_pk.c b/lib/gnutls_pk.c
index 1304d93d7c..86bd020ebe 100644
--- a/lib/gnutls_pk.c
+++ b/lib/gnutls_pk.c
@@ -31,26 +31,26 @@
 #include <x509_der.h>
 #include "debug.h"
 
-static int _gnutls_pk_encrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int pkey_len);
-static int _gnutls_pk_sign(int algo, MPI* data, MPI hash, MPI * pkey, int);
-static int _gnutls_pk_verify(int algo, MPI hash, MPI* data, MPI *pkey, int);
-static int _gnutls_pk_decrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int);
+static int _gnutls_pk_encrypt(int algo, GNUTLS_MPI * resarr, GNUTLS_MPI data, GNUTLS_MPI * pkey, int pkey_len);
+static int _gnutls_pk_sign(int algo, GNUTLS_MPI* data, GNUTLS_MPI hash, GNUTLS_MPI * pkey, int);
+static int _gnutls_pk_verify(int algo, GNUTLS_MPI hash, GNUTLS_MPI* data, GNUTLS_MPI *pkey, int);
+static int _gnutls_pk_decrypt(int algo, GNUTLS_MPI * resarr, GNUTLS_MPI data, GNUTLS_MPI * pkey, int);
 
 
 /* Do PKCS-1 RSA encryption. 
  * params is modulus, public exp.
  */
 int _gnutls_pkcs1_rsa_encrypt(gnutls_datum * ciphertext,
-			      gnutls_datum plaintext, MPI* params,
+			      gnutls_datum plaintext, GNUTLS_MPI* params,
 			      int params_len,
 			      int btype)
 {
 	int k, psize, i, ret, pad;
-	MPI m, res;
+	GNUTLS_MPI m, res;
 	opaque *edata, *ps;
 
 	
-	k = gcry_mpi_get_nbits(params[0]) / 8;
+	k = _gnutls_mpi_get_nbits(params[0]) / 8;
 
 	if (plaintext.size > k - 11) {
 		gnutls_assert();
@@ -161,14 +161,14 @@ int _gnutls_pkcs1_rsa_encrypt(gnutls_datum * ciphertext,
  * Can decrypt block type 1 and type 2 packets.
  */
 int _gnutls_pkcs1_rsa_decrypt(gnutls_sdatum * plaintext,
-			      gnutls_datum ciphertext, MPI* params, int params_len,
+			      gnutls_datum ciphertext, GNUTLS_MPI* params, int params_len,
 			      int btype)
 {
 	int k, esize, i, ret;
-	MPI c, res;
+	GNUTLS_MPI c, res;
 	opaque *edata;
 
-	k = gcry_mpi_get_nbits(params[0]) / 8;
+	k = _gnutls_mpi_get_nbits(params[0]) / 8;
 	esize = ciphertext.size;
 
 	if (esize != k) {
@@ -268,7 +268,7 @@ int _gnutls_pkcs1_rsa_decrypt(gnutls_sdatum * plaintext,
 
 
 int _gnutls_rsa_verify( const gnutls_datum* vdata, const gnutls_datum *ciphertext, 
-	MPI *params, int params_len, int btype) {
+	GNUTLS_MPI *params, int params_len, int btype) {
 
 	gnutls_datum plain;
 	int ret;
@@ -298,7 +298,7 @@ int _gnutls_rsa_verify( const gnutls_datum* vdata, const gnutls_datum *ciphertex
 
 /* encodes the Dss-Sig-Value structure
  */
-static int encode_ber_rs( gnutls_datum* sig_value, MPI r, MPI s) {
+static int encode_ber_rs( gnutls_datum* sig_value, GNUTLS_MPI r, GNUTLS_MPI s) {
 node_asn* sig;
 int result;
 opaque str[MAX_PARAMETER_SIZE];
@@ -365,9 +365,9 @@ int tot_len = 0;
 /* Do DSA signature calculation. params is p, q, g, y, x in that order.
  */
 int _gnutls_dsa_sign(gnutls_datum * signature, const gnutls_datum *hash,
-		     MPI * params, int params_len)
+		     GNUTLS_MPI * params, int params_len)
 {
-	MPI rs[2], mdata;
+	GNUTLS_MPI rs[2], mdata;
 	int k, ret;
 
 	k = hash->size;
@@ -406,7 +406,7 @@ int _gnutls_dsa_sign(gnutls_datum * signature, const gnutls_datum *hash,
 
 /* decodes the Dss-Sig-Value structure
  */
-static int decode_ber_rs( const gnutls_datum* sig_value, MPI* r, MPI* s) {
+static int decode_ber_rs( const gnutls_datum* sig_value, GNUTLS_MPI* r, GNUTLS_MPI* s) {
 node_asn* sig;
 int result;
 opaque str[MAX_PARAMETER_SIZE];
@@ -449,11 +449,11 @@ opaque str[MAX_PARAMETER_SIZE];
 /* params is p, q, g, y in that order
  */
 int _gnutls_dsa_verify( const gnutls_datum* vdata, const gnutls_datum *sig_value, 
-	MPI * params, int params_len) {
+	GNUTLS_MPI * params, int params_len) {
 
-	MPI mdata;
+	GNUTLS_MPI mdata;
 	int ret, k;
-	MPI rs[2];
+	GNUTLS_MPI rs[2];
 
 	if (vdata->size != 20) { /* sha-1 only */
 		gnutls_assert();
@@ -491,7 +491,7 @@ int _gnutls_dsa_verify( const gnutls_datum* vdata, const gnutls_datum *sig_value
  * Emulate our old PK interface here - sometime in the future we might
  * change the internal design to directly fit to libgcrypt.
  */
-static int _gnutls_pk_encrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int pkey_len)
+static int _gnutls_pk_encrypt(int algo, GNUTLS_MPI * resarr, GNUTLS_MPI data, GNUTLS_MPI * pkey, int pkey_len)
 {
 	GCRY_SEXP s_ciph, s_data, s_pkey;
 	int rc=-1;
@@ -553,7 +553,7 @@ static int _gnutls_pk_encrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int
 	return rc;
 }
 
-static int _gnutls_pk_decrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int pkey_len)
+static int _gnutls_pk_decrypt(int algo, GNUTLS_MPI * resarr, GNUTLS_MPI data, GNUTLS_MPI * pkey, int pkey_len)
 {
 	GCRY_SEXP s_plain, s_data, s_pkey;
 	int rc=-1;
@@ -612,7 +612,7 @@ static int _gnutls_pk_decrypt(int algo, MPI * resarr, MPI data, MPI * pkey, int
 /* in case of DSA puts into data, r,s
  */
 static 
-int _gnutls_pk_sign(int algo, MPI* data, MPI hash, MPI * pkey, int pkey_len)
+int _gnutls_pk_sign(int algo, GNUTLS_MPI* data, GNUTLS_MPI hash, GNUTLS_MPI * pkey, int pkey_len)
 {
 	GCRY_SEXP s_hash, s_key, s_sig;
 	int rc=-1;
@@ -703,7 +703,7 @@ int _gnutls_pk_sign(int algo, MPI* data, MPI hash, MPI * pkey, int pkey_len)
 }
 
 
-static int _gnutls_pk_verify(int algo, MPI hash, MPI* data, MPI *pkey, int pkey_len)
+static int _gnutls_pk_verify(int algo, GNUTLS_MPI hash, GNUTLS_MPI* data, GNUTLS_MPI *pkey, int pkey_len)
 {
 	GCRY_SEXP s_sig, s_hash, s_pkey;
 	int rc=-1;
diff --git a/lib/gnutls_privkey.c b/lib/gnutls_privkey.c
index e1b0aaa65c..f0b2c0a758 100644
--- a/lib/gnutls_privkey.c
+++ b/lib/gnutls_privkey.c
@@ -51,9 +51,9 @@ int _gnutls_PKCS1key2gnutlsKey(gnutls_private_key * pkey,
 		return _gnutls_asn2err(result);
 	}
 
-	if ((sizeof(pkey->params) / sizeof(MPI)) < RSA_PRIVATE_PARAMS) {
+	if ((sizeof(pkey->params) / sizeof(GNUTLS_MPI)) < RSA_PRIVATE_PARAMS) {
 		gnutls_assert();
-		/* internal error. Increase the MPIs in params */
+		/* internal error. Increase the GNUTLS_MPIs in params */
 		return GNUTLS_E_INTERNAL_ERROR;
 	}
 
@@ -120,14 +120,14 @@ int _gnutls_PKCS1key2gnutlsKey(gnutls_private_key * pkey,
 	 * library is uses the p,q in the reverse order.
 	 */
 	pkey->params[5] =
-	    gcry_mpi_snew(gcry_mpi_get_nbits(pkey->params[0]));
+	    _gnutls_mpi_snew(_gnutls_mpi_get_nbits(pkey->params[0]));
 
 	if (pkey->params[5] == NULL) {
 		gnutls_assert();
 		return GNUTLS_E_MEMORY_ERROR;
 	}
 
-	_gcry_mpi_invm(pkey->params[5], pkey->params[3], pkey->params[4]);
+	_gnutls_mpi_invm(pkey->params[5], pkey->params[3], pkey->params[4]);
 	/*				p, q */
 #else
 	if ( (result=_gnutls_x509_read_int( pkey_asn, "rsakey.coefficient",
@@ -180,9 +180,9 @@ int _gnutls_DSAkey2gnutlsKey(gnutls_private_key * pkey,
 		return _gnutls_asn2err(result);
 	}
 
-	if ((sizeof(pkey->params) / sizeof(MPI)) < DSA_PRIVATE_PARAMS) {
+	if ((sizeof(pkey->params) / sizeof(GNUTLS_MPI)) < DSA_PRIVATE_PARAMS) {
 		gnutls_assert();
-		/* internal error. Increase the MPIs in params */
+		/* internal error. Increase the GNUTLS_MPIs in params */
 		return GNUTLS_E_INTERNAL_ERROR;
 	}
 
diff --git a/lib/gnutls_srp.c b/lib/gnutls_srp.c
index 0aa59b958f..0bfb053f2a 100644
--- a/lib/gnutls_srp.c
+++ b/lib/gnutls_srp.c
@@ -35,11 +35,11 @@
  */
 
 
-int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, MPI g,
-		   MPI prime)
+int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, GNUTLS_MPI g,
+		   GNUTLS_MPI prime)
 {
 
-	MPI x, e;
+	GNUTLS_MPI x, e;
 	int result_size;
 
 	if (_gnutls_mpi_scan(&x, text, &textsize)) {
@@ -55,7 +55,7 @@ int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, MPI g,
 	}
 
 	/* e = g^x mod prime (n) */
-	gcry_mpi_powm(e, g, x, prime);
+	_gnutls_mpi_powm(e, g, x, prime);
 	_gnutls_mpi_release(&x);
 
 	_gnutls_mpi_print( NULL, &result_size, e);
@@ -77,21 +77,21 @@ int _gnutls_srp_gx(opaque * text, int textsize, opaque ** result, MPI g,
  * Choose a random value b and calculate B = (v + g^b) % N.
  * Return: B and if ret_b is not NULL b.
  */
-MPI _gnutls_calc_srp_B(MPI * ret_b, MPI g, MPI n, MPI v)
+GNUTLS_MPI _gnutls_calc_srp_B(GNUTLS_MPI * ret_b, GNUTLS_MPI g, GNUTLS_MPI n, GNUTLS_MPI v)
 {
-	MPI tmpB;
-	MPI b, B;
+	GNUTLS_MPI tmpB;
+	GNUTLS_MPI b, B;
 	int bits;
 
 	/* calculate:  B = (v + g^b) % N */
-	bits = gcry_mpi_get_nbits(n);
+	bits = _gnutls_mpi_get_nbits(n);
 	b = _gnutls_mpi_new(bits);	/* FIXME: allocate in secure memory */
 	if (b==NULL) {
 		gnutls_assert();
 		return NULL;
 	}
 	
-	gcry_mpi_randomize(b, bits, GCRY_STRONG_RANDOM);
+	_gnutls_mpi_randomize(b, bits, GCRY_STRONG_RANDOM);
 
 	tmpB = _gnutls_mpi_new(bits);	/* FIXME: allocate in secure memory */
 	if (tmpB==NULL) {
@@ -108,8 +108,8 @@ MPI _gnutls_calc_srp_B(MPI * ret_b, MPI g, MPI n, MPI v)
 		return NULL;
 	}
 
-	gcry_mpi_powm(tmpB, g, b, n);
-	gcry_mpi_addm(B, v, tmpB, n);
+	_gnutls_mpi_powm(tmpB, g, b, n);
+	_gnutls_mpi_addm(B, v, tmpB, n);
 
 	_gnutls_mpi_release(&tmpB);
 
@@ -121,13 +121,13 @@ MPI _gnutls_calc_srp_B(MPI * ret_b, MPI g, MPI n, MPI v)
 	return B;
 }
 
-MPI _gnutls_calc_srp_u(MPI B)
+GNUTLS_MPI _gnutls_calc_srp_u(GNUTLS_MPI B)
 {
 	int b_size;
 	opaque *b_holder, hd[MAX_HASH_SIZE];
 	GNUTLS_HASH_HANDLE td;
 	uint32 u;
-	MPI ret;
+	GNUTLS_MPI ret;
 
 	_gnutls_mpi_print( NULL, &b_size, B);
 	b_holder = gnutls_malloc(b_size);
@@ -149,7 +149,7 @@ MPI _gnutls_calc_srp_u(MPI B)
 
 	gnutls_free(b_holder);
 
-	ret = gcry_mpi_set_ui(NULL, u);
+	ret = _gnutls_mpi_set_ui(NULL, u);
 	if (ret==NULL) {
 		gnutls_assert();
 		return NULL;
@@ -161,10 +161,10 @@ MPI _gnutls_calc_srp_u(MPI B)
 /* S = (A * v^u) ^ b % N 
  * this is our shared key
  */
-MPI _gnutls_calc_srp_S1(MPI A, MPI b, MPI u, MPI v, MPI n)
+GNUTLS_MPI _gnutls_calc_srp_S1(GNUTLS_MPI A, GNUTLS_MPI b, GNUTLS_MPI u, GNUTLS_MPI v, GNUTLS_MPI n)
 {
-	MPI tmp1, tmp2;
-	MPI S;
+	GNUTLS_MPI tmp1, tmp2;
+	GNUTLS_MPI S;
 
 	S = _gnutls_mpi_alloc_like(n);
 	if (S==NULL)
@@ -179,11 +179,11 @@ MPI _gnutls_calc_srp_S1(MPI A, MPI b, MPI u, MPI v, MPI n)
 		return NULL;
 	}
 
-	gcry_mpi_powm(tmp1, v, u, n);
-	gcry_mpi_mulm(tmp2, A, tmp1, n);
+	_gnutls_mpi_powm(tmp1, v, u, n);
+	_gnutls_mpi_mulm(tmp2, A, tmp1, n);
 	_gnutls_mpi_release(&tmp1);
 
-	gcry_mpi_powm(S, tmp2, b, n);
+	_gnutls_mpi_powm(S, tmp2, b, n);
 	_gnutls_mpi_release(&tmp2);
 
 	return S;
@@ -192,20 +192,20 @@ MPI _gnutls_calc_srp_S1(MPI A, MPI b, MPI u, MPI v, MPI n)
 /* A = g^a % N 
  * returns A and a (which is random)
  */
-MPI _gnutls_calc_srp_A(MPI * a, MPI g, MPI n)
+GNUTLS_MPI _gnutls_calc_srp_A(GNUTLS_MPI * a, GNUTLS_MPI g, GNUTLS_MPI n)
 {
-	MPI tmpa;
-	MPI A;
+	GNUTLS_MPI tmpa;
+	GNUTLS_MPI A;
 	int bits;
 
-	bits = gcry_mpi_get_nbits(n);
+	bits = _gnutls_mpi_get_nbits(n);
 	tmpa = _gnutls_mpi_new(bits);	/* FIXME: allocate in secure memory */
 	if (tmpa==NULL) {
 		gnutls_assert();
 		return NULL;
 	}
 	
-	gcry_mpi_randomize(tmpa, bits, GCRY_STRONG_RANDOM);
+	_gnutls_mpi_randomize(tmpa, bits, GCRY_STRONG_RANDOM);
 
 	A = _gnutls_mpi_new(bits);	/* FIXME: allocate in secure memory */
 	if (A==NULL) {
@@ -213,7 +213,7 @@ MPI _gnutls_calc_srp_A(MPI * a, MPI g, MPI n)
 		_gnutls_mpi_release( &tmpa);
 		return NULL;
 	}
-	gcry_mpi_powm(A, g, tmpa, n);
+	_gnutls_mpi_powm(A, g, tmpa, n);
 
 	if (a != NULL)
 		*a = tmpa;
@@ -276,9 +276,9 @@ int _gnutls_calc_srp_x(char *username, char *password, opaque * salt,
 /* S = (B - g^x) ^ (a + u * x) % N
  * this is our shared key
  */
-MPI _gnutls_calc_srp_S2(MPI B, MPI g, MPI x, MPI a, MPI u, MPI n)
+GNUTLS_MPI _gnutls_calc_srp_S2(GNUTLS_MPI B, GNUTLS_MPI g, GNUTLS_MPI x, GNUTLS_MPI a, GNUTLS_MPI u, GNUTLS_MPI n)
 {
-	MPI S, tmp1, tmp2, tmp4;
+	GNUTLS_MPI S, tmp1, tmp2, tmp4;
 
 	S = _gnutls_mpi_alloc_like(n);
 	if (S==NULL)
@@ -292,19 +292,19 @@ MPI _gnutls_calc_srp_S2(MPI B, MPI g, MPI x, MPI a, MPI u, MPI n)
 		return NULL;
 	}
 
-	gcry_mpi_powm(tmp1, g, x, n);
+	_gnutls_mpi_powm(tmp1, g, x, n);
 
-	gcry_mpi_subm(tmp2, B, tmp1, n);
+	_gnutls_mpi_subm(tmp2, B, tmp1, n);
 
 	tmp4 = _gnutls_mpi_alloc_like(n);
 	if (tmp4==NULL)
 		return NULL;
 
-	gcry_mpi_mul(tmp1, u, x);
-	gcry_mpi_add(tmp4, a, tmp1);
+	_gnutls_mpi_mul(tmp1, u, x);
+	_gnutls_mpi_add(tmp4, a, tmp1);
 	_gnutls_mpi_release(&tmp1);
 
-	gcry_mpi_powm(S, tmp2, tmp4, n);
+	_gnutls_mpi_powm(S, tmp2, tmp4, n);
 	_gnutls_mpi_release(&tmp2);
 	_gnutls_mpi_release(&tmp4);
 
diff --git a/lib/gnutls_x509.c b/lib/gnutls_x509.c
index 35aa118a95..98034e96da 100644
--- a/lib/gnutls_x509.c
+++ b/lib/gnutls_x509.c
@@ -1614,7 +1614,7 @@ int gnutls_certificate_set_x509_key_mem(GNUTLS_CERTIFICATE_CREDENTIALS res, cons
 
 
 
-static int _read_rsa_params(opaque * der, int dersize, MPI * params)
+static int _read_rsa_params(opaque * der, int dersize, GNUTLS_MPI * params)
 {
 	opaque str[MAX_PARAMETER_SIZE];
 	int result;
@@ -1662,7 +1662,7 @@ static int _read_rsa_params(opaque * der, int dersize, MPI * params)
  * from the certificate 
  * params[0-2]
  */
-static int _read_dsa_params(opaque * der, int dersize, MPI * params)
+static int _read_dsa_params(opaque * der, int dersize, GNUTLS_MPI * params)
 {
 	opaque str[MAX_PARAMETER_SIZE];
 	int result;
@@ -1724,7 +1724,7 @@ static int _read_dsa_params(opaque * der, int dersize, MPI * params)
  * from the certificate 
  * params[3]
  */
-static int _read_dsa_pubkey(opaque * der, int dersize, MPI * params)
+static int _read_dsa_pubkey(opaque * der, int dersize, GNUTLS_MPI * params)
 {
 	opaque str[MAX_PARAMETER_SIZE];
 	int result;
@@ -1786,9 +1786,9 @@ int len, result;
 		 */
 		gCert->subject_pk_algorithm = GNUTLS_PK_RSA;
 
-		if ((sizeof(gCert->params) / sizeof(MPI)) < RSA_PUBLIC_PARAMS) {
+		if ((sizeof(gCert->params) / sizeof(GNUTLS_MPI)) < RSA_PUBLIC_PARAMS) {
 			gnutls_assert();
-			/* internal error. Increase the MPIs in params */
+			/* internal error. Increase the GNUTLS_MPIs in params */
 			return GNUTLS_E_INTERNAL_ERROR;
 		}
 
@@ -1810,9 +1810,9 @@ int len, result;
 		 */
 		gCert->subject_pk_algorithm = GNUTLS_PK_DSA;
 
-		if ((sizeof(gCert->params) / sizeof(MPI)) < DSA_PUBLIC_PARAMS) {
+		if ((sizeof(gCert->params) / sizeof(GNUTLS_MPI)) < DSA_PUBLIC_PARAMS) {
 			gnutls_assert();
-			/* internal error. Increase the MPIs in params */
+			/* internal error. Increase the GNUTLS_MPIs in params */
 			return GNUTLS_E_INTERNAL_ERROR;
 		}
 
@@ -2306,7 +2306,7 @@ int gnutls_x509_extract_certificate_pk_algorithm( const gnutls_datum * cert, int
 	opaque str[MAX_X509_CERT_SIZE];
 	int algo;
 	int len = sizeof(str);
-	MPI params[MAX_PARAMS_SIZE];
+	GNUTLS_MPI params[MAX_PARAMS_SIZE];
 
 	if ((result=asn1_create_structure
 	    (_gnutls_get_pkix(), "PKIX1.Certificate", &c2,
@@ -2375,7 +2375,7 @@ int gnutls_x509_extract_certificate_pk_algorithm( const gnutls_datum * cert, int
 			return result;
 		}
 
-		bits[0] = gcry_mpi_get_nbits( params[0]);
+		bits[0] = _gnutls_mpi_get_nbits( params[0]);
 	
 		_gnutls_mpi_release( &params[0]);
 		_gnutls_mpi_release( &params[1]);
@@ -2390,7 +2390,7 @@ int gnutls_x509_extract_certificate_pk_algorithm( const gnutls_datum * cert, int
 			return result;
 		}
 
-		bits[0] = gcry_mpi_get_nbits( params[3]);
+		bits[0] = _gnutls_mpi_get_nbits( params[3]);
 
 		_gnutls_mpi_release( &params[3]);
 	}
diff --git a/lib/x509_sig_check.c b/lib/x509_sig_check.c
index c5e73bc217..fe1d5b90e8 100644
--- a/lib/x509_sig_check.c
+++ b/lib/x509_sig_check.c
@@ -140,7 +140,7 @@ int len;
  * params[1] is public key
  */
 static int
-_pkcs1_rsa_verify_sig( const gnutls_datum* signature, gnutls_datum* text, MPI *params, int params_len)
+_pkcs1_rsa_verify_sig( const gnutls_datum* signature, gnutls_datum* text, GNUTLS_MPI *params, int params_len)
 {
 	MACAlgorithm hash;
 	int ret;