};
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;
}
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;
}
_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;
}
int gen_anon_client_kx( GNUTLS_STATE state, opaque** data) {
-MPI x, X;
+GNUTLS_MPI x, X;
size_t n_X;
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;
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();
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;
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;
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;
}
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;
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;
static int gen_dhe_client_kx(GNUTLS_STATE state, opaque ** data)
{
- MPI x, X;
+ GNUTLS_MPI x, X;
size_t n_X;
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;
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();
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();
{
uint16 n_Y;
size_t _n_Y;
- MPI g, p;
+ GNUTLS_MPI g, p;
int bits, ret;
const GNUTLS_CERTIFICATE_CREDENTIALS cred;
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();
/* 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);
*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);
/* 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;
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) {
{
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;
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);
if (data_size < n_n + n_g + pwd_entry->salt_size + 6 + 1) {
gnutls_assert();
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;
int _gnutls_srp_generate_prime(opaque ** ret_g, opaque ** ret_n, int bits)
{
- MPI prime, g;
+ GNUTLS_MPI prime, g;
int siz;
char *tmp;
#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 */
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]) {
#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;
/* 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;
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);
/* 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;
#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);
}
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) {
/* 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 */
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);
_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;
}
-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;
}
};
/* 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)}
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;
}
-/* 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)
/* 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) {
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++;
/* 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) {
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++;
}
/* 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 */
**/
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;
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();
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) {
/* 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);
}
* 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;
# 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);
} keyring_blob_types;
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++;
}
}
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)
{
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)
{
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)
{
int key_fpr_size);
#endif /*GNUTLS_OPENPGP_H*/
-
-
-
-
-
-
-
-
-
#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();
* 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) {
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;
/* 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];
/* 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;
/* 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];
/* 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();
* 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;
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;
/* 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;
}
-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;
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;
}
* 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",
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;
}
*/
-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)) {
}
/* 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);
* 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) {
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);
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);
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;
/* 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)
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;
/* 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) {
_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;
/* 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)
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);
-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;
* 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;
* 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;
*/
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;
}
*/
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;
}
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,
return result;
}
- bits[0] = gcry_mpi_get_nbits( params[0]);
+ bits[0] = _gnutls_mpi_get_nbits( params[0]);
_gnutls_mpi_release( ¶ms[0]);
_gnutls_mpi_release( ¶ms[1]);
return result;
}
- bits[0] = gcry_mpi_get_nbits( params[3]);
+ bits[0] = _gnutls_mpi_get_nbits( params[3]);
_gnutls_mpi_release( ¶ms[3]);
}
/* A Bison parser, made from x509_ASN.y
- by GNU bison 1.32. */
+ by GNU bison 1.35. */
#define YYBISON 1 /* Identify Bison output. */
node_asn* node;
} yystype;
# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
#endif
#ifndef YYDEBUG
# define YYDEBUG 0
"type_assig_right_tag_default", "type_assig", "type_assig_list",
"sequence_def", "set_def", "choise_def", "any_def", "type_def",
"constant_def", "type_constant", "type_constant_list", "definitions_id",
- "imports_def", "explicit_implicit", "definitions", NULL
+ "imports_def", "explicit_implicit", "definitions", 0
};
#endif
#line 3 "/usr/share/bison/bison.simple"
/* Skeleton output parser for bison,
- Copyright (C) 1984, 1989, 1990, 2000, 2001 Free Software Foundation, Inc.
+
+ Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
+ Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below. */
-#ifdef __cplusplus
-# define YYSTD(x) std::x
-#else
-# define YYSTD(x) x
-#endif
-
#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
/* The parser invokes alloca or malloc; define the necessary symbols. */
# if YYSTACK_USE_ALLOCA
# define YYSTACK_ALLOC alloca
-# define YYSIZE_T YYSTD (size_t)
# else
# ifndef YYSTACK_USE_ALLOCA
# if defined (alloca) || defined (_ALLOCA_H)
# define YYSTACK_ALLOC alloca
-# define YYSIZE_T YYSTD (size_t)
# else
# ifdef __GNUC__
# define YYSTACK_ALLOC __builtin_alloca
/* Pacify GCC's `empty if-body' warning. */
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
# else
-# ifdef __cplusplus
-# include <cstdlib> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T std::size_t
-# else
-# ifdef __STDC__
-# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# endif
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
# endif
-# define YYSTACK_ALLOC YYSTD (malloc)
-# define YYSTACK_FREE YYSTD (free)
+# define YYSTACK_ALLOC malloc
+# define YYSTACK_FREE free
# endif
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if (! defined (yyoverflow) \
+ && (! defined (__cplusplus) \
+ || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
/* A type that is properly aligned for any stack member. */
union yyalloc
+ YYSTACK_GAP_MAX)
# endif
-/* Relocate the TYPE STACK from its old location to the new one. The
+/* Copy COUNT objects from FROM to TO. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if 1 < __GNUC__
+# define YYCOPY(To, From, Count) \
+ __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+# else
+# define YYCOPY(To, From, Count) \
+ do \
+ { \
+ register YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (To)[yyi] = (From)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+
+/* Relocate STACK from its old location to the new one. The
local variables YYSIZE and YYSTACKSIZE give the old and new number of
elements in the stack, and YYPTR gives the new location of the
stack. Advance YYPTR to a properly aligned location for the next
stack. */
-# define YYSTACK_RELOCATE(Type, Stack) \
+# define YYSTACK_RELOCATE(Stack) \
do \
{ \
YYSIZE_T yynewbytes; \
- yymemcpy ((char *) yyptr, (char *) (Stack), \
- yysize * (YYSIZE_T) sizeof (Type)); \
+ YYCOPY (&yyptr->Stack, Stack, yysize); \
Stack = &yyptr->Stack; \
- yynewbytes = yystacksize * sizeof (Type) + YYSTACK_GAP_MAX; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
-#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+#endif
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
# define YYSIZE_T size_t
#endif
#if ! defined (YYSIZE_T)
-# ifdef __cplusplus
-# include <cstddef> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T std::size_t
-# else
-# ifdef __STDC__
-# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
-# define YYSIZE_T size_t
-# endif
+# if defined (__STDC__) || defined (__cplusplus)
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
# endif
#endif
#if ! defined (YYSIZE_T)
#if YYDEBUG
# ifndef YYFPRINTF
-# ifdef __cplusplus
-# include <cstdio> /* INFRINGES ON USER NAME SPACE */
-# else
-# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
-# endif
-# define YYFPRINTF YYSTD (fprintf)
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
# endif
# define YYDPRINTF(Args) \
if (yydebug) \
YYFPRINTF Args; \
} while (0)
-/* Nonzero means print parse trace. [The following comment makes no
- sense to me. Could someone clarify it? --akim] Since this is
- uninitialized, it does not stop multiple parsers from coexisting.
- */
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
int yydebug;
#else /* !YYDEBUG */
# define YYDPRINTF(Args)
# define YYMAXDEPTH 10000
#endif
\f
-#if ! defined (yyoverflow) && ! defined (yymemcpy)
-# if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
-# define yymemcpy __builtin_memcpy
-# else /* not GNU C or C++ */
-
-/* This is the most reliable way to avoid incompatibilities
- in available built-in functions on various systems. */
-static void
-# if defined (__STDC__) || defined (__cplusplus)
-yymemcpy (char *yyto, const char *yyfrom, YYSIZE_T yycount)
-# else
-yymemcpy (yyto, yyfrom, yycount)
- char *yyto;
- const char *yyfrom;
- YYSIZE_T yycount;
-# endif
-{
- register const char *yyf = yyfrom;
- register char *yyt = yyto;
- register YYSIZE_T yyi = yycount;
-
- while (yyi-- != 0)
- *yyt++ = *yyf++;
-}
-# endif
-#endif
-
#ifdef YYERROR_VERBOSE
# ifndef yystrlen
# endif
#endif
\f
-#line 341 "/usr/share/bison/bison.simple"
+#line 315 "/usr/share/bison/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
to the proper pointer type. */
#ifdef YYPARSE_PARAM
-# ifdef __cplusplus
+# if defined (__STDC__) || defined (__cplusplus)
# define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
# define YYPARSE_PARAM_DECL
-# else /* !__cplusplus */
+# else
# define YYPARSE_PARAM_ARG YYPARSE_PARAM
# define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
-# endif /* !__cplusplus */
+# endif
#else /* !YYPARSE_PARAM */
# define YYPARSE_PARAM_ARG
# define YYPARSE_PARAM_DECL
yyvs = yyvs1;
}
#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyoverflowlab;
+# else
/* Extend the stack our own way. */
if (yystacksize >= YYMAXDEPTH)
goto yyoverflowlab;
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
if (! yyptr)
goto yyoverflowlab;
- YYSTACK_RELOCATE (short, yyss);
- YYSTACK_RELOCATE (YYSTYPE, yyvs);
+ YYSTACK_RELOCATE (yyss);
+ YYSTACK_RELOCATE (yyvs);
# if YYLSP_NEEDED
- YYSTACK_RELOCATE (YYLTYPE, yyls);
+ YYSTACK_RELOCATE (yyls);
# endif
# undef YYSTACK_RELOCATE
if (yyss1 != yyssa)
YYSTACK_FREE (yyss1);
}
+# endif
#endif /* no yyoverflow */
yyssp = yyss + yysize - 1;
break;
}
-#line 727 "/usr/share/bison/bison.simple"
+#line 705 "/usr/share/bison/bison.simple"
\f
yyvsp -= yylen;
* 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;
projects / thirdparty / gnutls.git / commitdiff
