diff --git a/cipher/pubkey.c b/cipher/pubkey.c
index ffebb098..2ce96f59 100644
--- a/cipher/pubkey.c
+++ b/cipher/pubkey.c
@@ -1,1158 +1,1158 @@
/* pubkey.c - pubkey dispatcher
* Copyright (C) 1998, 1999, 2000, 2002, 2003, 2005,
* 2007, 2008, 2011 Free Software Foundation, Inc.
* Copyright (C) 2013 g10 Code GmbH
*
* This file is part of Libgcrypt.
*
* Libgcrypt is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser general Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* Libgcrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see .
*/
#include
#include
#include
#include
#include
#include "g10lib.h"
#include "mpi.h"
#include "cipher.h"
#include "context.h"
#include "pubkey-internal.h"
/* This is the list of the public-key algorithms included in
Libgcrypt. */
static gcry_pk_spec_t * const pubkey_list[] =
{
#if USE_ECC
&_gcry_pubkey_spec_ecc,
#endif
#if USE_RSA
&_gcry_pubkey_spec_rsa,
#endif
#if USE_DSA
&_gcry_pubkey_spec_dsa,
#endif
#if USE_ELGAMAL
&_gcry_pubkey_spec_elg,
#endif
NULL
};
static int
map_algo (int algo)
{
switch (algo)
{
case GCRY_PK_RSA_E: return GCRY_PK_RSA;
case GCRY_PK_RSA_S: return GCRY_PK_RSA;
case GCRY_PK_ELG_E: return GCRY_PK_ELG;
case GCRY_PK_ECDSA: return GCRY_PK_ECC;
case GCRY_PK_EDDSA: return GCRY_PK_ECC;
case GCRY_PK_ECDH: return GCRY_PK_ECC;
default: return algo;
}
}
/* Return the spec structure for the public key algorithm ALGO. For
an unknown algorithm NULL is returned. */
static gcry_pk_spec_t *
spec_from_algo (int algo)
{
int idx;
gcry_pk_spec_t *spec;
algo = map_algo (algo);
for (idx = 0; (spec = pubkey_list[idx]); idx++)
if (algo == spec->algo)
return spec;
return NULL;
}
/* Return the spec structure for the public key algorithm with NAME.
For an unknown name NULL is returned. */
static gcry_pk_spec_t *
spec_from_name (const char *name)
{
gcry_pk_spec_t *spec;
int idx;
const char **aliases;
for (idx=0; (spec = pubkey_list[idx]); idx++)
{
if (!stricmp (name, spec->name))
return spec;
for (aliases = spec->aliases; *aliases; aliases++)
if (!stricmp (name, *aliases))
return spec;
}
return NULL;
}
/* Given the s-expression SEXP with the first element be either
* "private-key" or "public-key" return the spec structure for it. We
* look through the list to find a list beginning with "private-key"
* or "public-key" - the first one found is used. If WANT_PRIVATE is
* set the function will only succeed if a private key has been given.
* On success the spec is stored at R_SPEC. On error NULL is stored
* at R_SPEC and an error code returned. If R_PARMS is not NULL and
* the function returns success, the parameter list below
* "private-key" or "public-key" is stored there and the caller must
* call gcry_sexp_release on it.
*/
static gcry_err_code_t
spec_from_sexp (gcry_sexp_t sexp, int want_private,
gcry_pk_spec_t **r_spec, gcry_sexp_t *r_parms)
{
gcry_sexp_t list, l2;
char *name;
gcry_pk_spec_t *spec;
*r_spec = NULL;
if (r_parms)
*r_parms = NULL;
/* Check that the first element is valid. If we are looking for a
public key but a private key was supplied, we allow the use of
the private key anyway. The rationale for this is that the
private key is a superset of the public key. */
list = sexp_find_token (sexp, want_private? "private-key":"public-key", 0);
if (!list && !want_private)
list = sexp_find_token (sexp, "private-key", 0);
if (!list)
return GPG_ERR_INV_OBJ; /* Does not contain a key object. */
l2 = sexp_cadr (list);
sexp_release (list);
list = l2;
name = sexp_nth_string (list, 0);
if (!name)
{
sexp_release ( list );
return GPG_ERR_INV_OBJ; /* Invalid structure of object. */
}
spec = spec_from_name (name);
xfree (name);
if (!spec)
{
sexp_release (list);
return GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
}
*r_spec = spec;
if (r_parms)
*r_parms = list;
else
sexp_release (list);
return 0;
}
/* Disable the use of the algorithm ALGO. This is not thread safe and
should thus be called early. */
static void
disable_pubkey_algo (int algo)
{
gcry_pk_spec_t *spec = spec_from_algo (algo);
if (spec)
spec->flags.disabled = 1;
}
/*
* Map a string to the pubkey algo
*/
int
_gcry_pk_map_name (const char *string)
{
gcry_pk_spec_t *spec;
if (!string)
return 0;
spec = spec_from_name (string);
if (!spec)
return 0;
if (spec->flags.disabled)
return 0;
return spec->algo;
}
/* Map the public key algorithm whose ID is contained in ALGORITHM to
a string representation of the algorithm name. For unknown
algorithm IDs this functions returns "?". */
const char *
_gcry_pk_algo_name (int algo)
{
gcry_pk_spec_t *spec;
spec = spec_from_algo (algo);
if (spec)
return spec->name;
return "?";
}
/****************
* A USE of 0 means: don't care.
*/
static gcry_err_code_t
check_pubkey_algo (int algo, unsigned use)
{
gcry_err_code_t err = 0;
gcry_pk_spec_t *spec;
spec = spec_from_algo (algo);
if (spec)
{
if (((use & GCRY_PK_USAGE_SIGN)
&& (! (spec->use & GCRY_PK_USAGE_SIGN)))
|| ((use & GCRY_PK_USAGE_ENCR)
&& (! (spec->use & GCRY_PK_USAGE_ENCR))))
err = GPG_ERR_WRONG_PUBKEY_ALGO;
}
else
err = GPG_ERR_PUBKEY_ALGO;
return err;
}
/****************
* Return the number of public key material numbers
*/
static int
pubkey_get_npkey (int algo)
{
gcry_pk_spec_t *spec = spec_from_algo (algo);
return spec? strlen (spec->elements_pkey) : 0;
}
/****************
* Return the number of secret key material numbers
*/
static int
pubkey_get_nskey (int algo)
{
gcry_pk_spec_t *spec = spec_from_algo (algo);
return spec? strlen (spec->elements_skey) : 0;
}
/****************
* Return the number of signature material numbers
*/
static int
pubkey_get_nsig (int algo)
{
gcry_pk_spec_t *spec = spec_from_algo (algo);
return spec? strlen (spec->elements_sig) : 0;
}
/****************
* Return the number of encryption material numbers
*/
static int
pubkey_get_nenc (int algo)
{
gcry_pk_spec_t *spec = spec_from_algo (algo);
return spec? strlen (spec->elements_enc) : 0;
}
/*
Do a PK encrypt operation
Caller has to provide a public key as the SEXP pkey and data as a
SEXP with just one MPI in it. Alternatively S_DATA might be a
complex S-Expression, similar to the one used for signature
verification. This provides a flag which allows to handle PKCS#1
block type 2 padding. The function returns a sexp which may be
passed to to pk_decrypt.
Returns: 0 or an errorcode.
s_data = See comment for _gcry_pk_util_data_to_mpi
s_pkey =
r_ciph = (enc-val
(
( )
...
( )
))
*/
gcry_err_code_t
_gcry_pk_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t s_pkey)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms;
*r_ciph = NULL;
rc = spec_from_sexp (s_pkey, 0, &spec, &keyparms);
if (rc)
goto leave;
if (spec->encrypt)
rc = spec->encrypt (r_ciph, s_data, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (keyparms);
return rc;
}
/*
Do a PK decrypt operation
Caller has to provide a secret key as the SEXP skey and data in a
format as created by gcry_pk_encrypt. For historic reasons the
function returns simply an MPI as an S-expression part; this is
deprecated and the new method should be used which returns a real
S-expressionl this is selected by adding at least an empty flags
list to S_DATA.
Returns: 0 or an errorcode.
s_data = (enc-val
[(flags [raw, pkcs1, oaep])]
(
( )
...
( )
))
s_skey =
r_plain= Either an incomplete S-expression without the parentheses
or if the flags list is used (even if empty) a real S-expression:
(value PLAIN). In raw mode (or no flags given) the returned value
is to be interpreted as a signed MPI, thus it may have an extra
leading zero octet even if not included in the original data.
With pkcs1 or oaep decoding enabled the returned value is a
verbatim octet string.
*/
gcry_err_code_t
_gcry_pk_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t s_skey)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms;
*r_plain = NULL;
rc = spec_from_sexp (s_skey, 1, &spec, &keyparms);
if (rc)
goto leave;
if (spec->decrypt)
rc = spec->decrypt (r_plain, s_data, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (keyparms);
return rc;
}
/*
Create a signature.
Caller has to provide a secret key as the SEXP skey and data
expressed as a SEXP list hash with only one element which should
instantly be available as a MPI. Alternatively the structure given
below may be used for S_HASH, it provides the abiliy to pass flags
to the operation; the flags defined by now are "pkcs1" which does
PKCS#1 block type 1 style padding and "pss" for PSS encoding.
Returns: 0 or an errorcode.
In case of 0 the function returns a new SEXP with the
signature value; the structure of this signature depends on the
other arguments but is always suitable to be passed to
gcry_pk_verify
s_hash = See comment for _gcry-pk_util_data_to_mpi
s_skey =
r_sig = (sig-val
(
( )
...
( ))
[(hash algo)])
Note that (hash algo) in R_SIG is not used.
*/
gcry_err_code_t
_gcry_pk_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_hash, gcry_sexp_t s_skey)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms;
*r_sig = NULL;
rc = spec_from_sexp (s_skey, 1, &spec, &keyparms);
if (rc)
goto leave;
if (spec->sign)
rc = spec->sign (r_sig, s_hash, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (keyparms);
return rc;
}
gcry_err_code_t
_gcry_pk_sign_md (gcry_sexp_t *r_sig, const char *tmpl, gcry_md_hd_t hd_orig,
gcry_sexp_t s_skey, gcry_ctx_t ctx)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms = NULL;
gcry_sexp_t s_hash = NULL;
int algo;
const unsigned char *digest;
gcry_error_t err;
gcry_md_hd_t hd;
*r_sig = NULL;
err = _gcry_md_copy (&hd, hd_orig);
if (err)
return gpg_err_code (err);
algo = _gcry_md_get_algo (hd);
digest = _gcry_md_read (hd, 0);
if (!digest)
{
_gcry_md_close (hd);
return GPG_ERR_NOT_IMPLEMENTED;
}
if (!ctx)
rc = _gcry_sexp_build (&s_hash, NULL, tmpl,
_gcry_md_algo_name (algo),
(int) _gcry_md_get_algo_dlen (algo),
digest);
else
{
const unsigned char *p;
size_t len;
rc = _gcry_pk_get_random_override (ctx, &p, &len);
if (rc)
{
_gcry_md_close (hd);
return rc;
}
rc = _gcry_sexp_build (&s_hash, NULL, tmpl,
_gcry_md_algo_name (algo),
(int) _gcry_md_get_algo_dlen (algo),
digest,
(int) len, p);
}
_gcry_md_close (hd);
if (rc)
return rc;
rc = spec_from_sexp (s_skey, 1, &spec, &keyparms);
if (rc)
goto leave;
if (spec->sign)
rc = spec->sign (r_sig, s_hash, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (s_hash);
sexp_release (keyparms);
return rc;
}
/*
Verify a signature.
Caller has to supply the public key pkey, the signature sig and his
hashvalue data. Public key has to be a standard public key given
as an S-Exp, sig is a S-Exp as returned from gcry_pk_sign and data
must be an S-Exp like the one in sign too. */
gcry_err_code_t
_gcry_pk_verify (gcry_sexp_t s_sig, gcry_sexp_t s_hash, gcry_sexp_t s_pkey)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms;
rc = spec_from_sexp (s_pkey, 0, &spec, &keyparms);
if (rc)
goto leave;
if (spec->verify)
rc = spec->verify (s_sig, s_hash, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (keyparms);
return rc;
}
gcry_err_code_t
_gcry_pk_verify_md (gcry_sexp_t s_sig, const char *tmpl, gcry_md_hd_t hd_orig,
gcry_sexp_t s_pkey, gcry_ctx_t ctx)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms = NULL;
gcry_sexp_t s_hash = NULL;
int algo;
const unsigned char *digest;
gcry_error_t err;
gcry_md_hd_t hd;
err = _gcry_md_copy (&hd, hd_orig);
if (err)
return gpg_err_code (err);
algo = _gcry_md_get_algo (hd);
digest = _gcry_md_read (hd, 0);
if (!digest)
{
_gcry_md_close (hd);
return GPG_ERR_DIGEST_ALGO;
}
if (!ctx)
rc = _gcry_sexp_build (&s_hash, NULL, tmpl,
_gcry_md_algo_name (algo),
(int) _gcry_md_get_algo_dlen (algo),
digest);
else
{
const unsigned char *p;
size_t len;
rc = _gcry_pk_get_random_override (ctx, &p, &len);
if (rc)
{
_gcry_md_close (hd);
return rc;
}
rc = _gcry_sexp_build (&s_hash, NULL, tmpl,
_gcry_md_algo_name (algo),
(int) _gcry_md_get_algo_dlen (algo),
digest,
(int) len, p);
}
_gcry_md_close (hd);
if (rc)
return rc;
- rc = spec_from_sexp (s_pkey, 1, &spec, &keyparms);
+ rc = spec_from_sexp (s_pkey, 0, &spec, &keyparms);
if (rc)
goto leave;
if (spec->verify)
rc = spec->verify (s_sig, s_hash, keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (s_hash);
sexp_release (keyparms);
return rc;
}
/*
Test a key.
This may be used either for a public or a secret key to see whether
the internal structure is okay.
Returns: 0 or an errorcode.
NOTE: We currently support only secret key checking. */
gcry_err_code_t
_gcry_pk_testkey (gcry_sexp_t s_key)
{
gcry_err_code_t rc;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms;
rc = spec_from_sexp (s_key, 1, &spec, &keyparms);
if (rc)
goto leave;
if (spec->check_secret_key)
rc = spec->check_secret_key (keyparms);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (keyparms);
return rc;
}
/*
Create a public key pair and return it in r_key.
How the key is created depends on s_parms:
(genkey
(algo
(parameter_name_1 ....)
....
(parameter_name_n ....)
))
The key is returned in a format depending on the
algorithm. Both, private and secret keys are returned
and optionally some additional informatin.
For elgamal we return this structure:
(key-data
(public-key
(elg
(p )
(g )
(y )
)
)
(private-key
(elg
(p )
(g )
(y )
(x )
)
)
(misc-key-info
(pm1-factors n1 n2 ... nn)
))
*/
gcry_err_code_t
_gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
{
gcry_pk_spec_t *spec = NULL;
gcry_sexp_t list = NULL;
gcry_sexp_t l2 = NULL;
char *name = NULL;
gcry_err_code_t rc;
*r_key = NULL;
list = sexp_find_token (s_parms, "genkey", 0);
if (!list)
{
rc = GPG_ERR_INV_OBJ; /* Does not contain genkey data. */
goto leave;
}
l2 = sexp_cadr (list);
sexp_release (list);
list = l2;
l2 = NULL;
if (! list)
{
rc = GPG_ERR_NO_OBJ; /* No cdr for the genkey. */
goto leave;
}
name = _gcry_sexp_nth_string (list, 0);
if (!name)
{
rc = GPG_ERR_INV_OBJ; /* Algo string missing. */
goto leave;
}
spec = spec_from_name (name);
xfree (name);
name = NULL;
if (!spec)
{
rc = GPG_ERR_PUBKEY_ALGO; /* Unknown algorithm. */
goto leave;
}
if (spec->generate)
rc = spec->generate (list, r_key);
else
rc = GPG_ERR_NOT_IMPLEMENTED;
leave:
sexp_release (list);
xfree (name);
sexp_release (l2);
return rc;
}
/*
Get the number of nbits from the public key.
Hmmm: Should we have really this function or is it better to have a
more general function to retrieve different properties of the key? */
unsigned int
_gcry_pk_get_nbits (gcry_sexp_t key)
{
gcry_pk_spec_t *spec;
gcry_sexp_t parms;
unsigned int nbits;
/* Parsing KEY might be considered too much overhead. For example
for RSA we would only need to look at P and stop parsing right
away. However, with ECC things are more complicate in that only
a curve name might be specified. Thus we need to tear the sexp
apart. */
if (spec_from_sexp (key, 0, &spec, &parms))
return 0; /* Error - 0 is a suitable indication for that. */
nbits = spec->get_nbits (parms);
sexp_release (parms);
return nbits;
}
/* Return the so called KEYGRIP which is the SHA-1 hash of the public
key parameters expressed in a way depending on the algorithm.
ARRAY must either be 20 bytes long or NULL; in the latter case a
newly allocated array of that size is returned, otherwise ARRAY or
NULL is returned to indicate an error which is most likely an
unknown algorithm. The function accepts public or secret keys. */
unsigned char *
_gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
{
gcry_sexp_t list = NULL;
gcry_sexp_t l2 = NULL;
gcry_pk_spec_t *spec = NULL;
const char *s;
char *name = NULL;
int idx;
const char *elems;
gcry_md_hd_t md = NULL;
int okay = 0;
/* Check that the first element is valid. */
list = sexp_find_token (key, "public-key", 0);
if (! list)
list = sexp_find_token (key, "private-key", 0);
if (! list)
list = sexp_find_token (key, "protected-private-key", 0);
if (! list)
list = sexp_find_token (key, "shadowed-private-key", 0);
if (! list)
return NULL; /* No public- or private-key object. */
l2 = sexp_cadr (list);
sexp_release (list);
list = l2;
l2 = NULL;
name = _gcry_sexp_nth_string (list, 0);
if (!name)
goto fail; /* Invalid structure of object. */
spec = spec_from_name (name);
if (!spec)
goto fail; /* Unknown algorithm. */
elems = spec->elements_grip;
if (!elems)
goto fail; /* No grip parameter. */
if (_gcry_md_open (&md, GCRY_MD_SHA1, 0))
goto fail;
if (spec->comp_keygrip)
{
/* Module specific method to compute a keygrip. */
if (spec->comp_keygrip (md, list))
goto fail;
}
else
{
/* Generic method to compute a keygrip. */
for (idx = 0, s = elems; *s; s++, idx++)
{
const char *data;
size_t datalen;
char buf[30];
l2 = sexp_find_token (list, s, 1);
if (! l2)
goto fail;
data = sexp_nth_data (l2, 1, &datalen);
if (! data)
goto fail;
snprintf (buf, sizeof buf, "(1:%c%u:", *s, (unsigned int)datalen);
_gcry_md_write (md, buf, strlen (buf));
_gcry_md_write (md, data, datalen);
sexp_release (l2);
l2 = NULL;
_gcry_md_write (md, ")", 1);
}
}
if (!array)
{
array = xtrymalloc (20);
if (! array)
goto fail;
}
memcpy (array, _gcry_md_read (md, GCRY_MD_SHA1), 20);
okay = 1;
fail:
xfree (name);
sexp_release (l2);
_gcry_md_close (md);
sexp_release (list);
return okay? array : NULL;
}
const char *
_gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
{
const char *result = NULL;
gcry_pk_spec_t *spec;
gcry_sexp_t keyparms = NULL;
if (r_nbits)
*r_nbits = 0;
if (key)
{
iterator = 0;
if (spec_from_sexp (key, 0, &spec, &keyparms))
return NULL;
}
else
{
spec = spec_from_name ("ecc");
if (!spec)
return NULL;
}
if (spec->get_curve)
result = spec->get_curve (keyparms, iterator, r_nbits);
sexp_release (keyparms);
return result;
}
gcry_sexp_t
_gcry_pk_get_param (int algo, const char *name)
{
gcry_sexp_t result = NULL;
gcry_pk_spec_t *spec = NULL;
algo = map_algo (algo);
if (algo != GCRY_PK_ECC)
return NULL;
spec = spec_from_name ("ecc");
if (spec)
{
if (spec && spec->get_curve_param)
result = spec->get_curve_param (name);
}
return result;
}
gcry_err_code_t
_gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
{
gcry_err_code_t rc = 0;
switch (cmd)
{
case GCRYCTL_DISABLE_ALGO:
/* This one expects a buffer pointing to an integer with the
algo number. */
if ((! buffer) || (buflen != sizeof (int)))
rc = GPG_ERR_INV_ARG;
else
disable_pubkey_algo (*((int *) buffer));
break;
default:
rc = GPG_ERR_INV_OP;
}
return rc;
}
/* Return information about the given algorithm
WHAT selects the kind of information returned:
GCRYCTL_TEST_ALGO:
Returns 0 when the specified algorithm is available for use.
Buffer must be NULL, nbytes may have the address of a variable
with the required usage of the algorithm. It may be 0 for don't
care or a combination of the GCRY_PK_USAGE_xxx flags;
GCRYCTL_GET_ALGO_USAGE:
Return the usage flags for the given algo. An invalid algo
returns 0. Disabled algos are ignored here because we
only want to know whether the algo is at all capable of
the usage.
Note: Because this function is in most cases used to return an
integer value, we can make it easier for the caller to just look at
the return value. The caller will in all cases consult the value
and thereby detecting whether a error occurred or not (i.e. while
checking the block size) */
gcry_err_code_t
_gcry_pk_algo_info (int algorithm, int what, void *buffer, size_t *nbytes)
{
gcry_err_code_t rc = 0;
switch (what)
{
case GCRYCTL_TEST_ALGO:
{
int use = nbytes ? *nbytes : 0;
if (buffer)
rc = GPG_ERR_INV_ARG;
else if (check_pubkey_algo (algorithm, use))
rc = GPG_ERR_PUBKEY_ALGO;
break;
}
case GCRYCTL_GET_ALGO_USAGE:
{
gcry_pk_spec_t *spec;
spec = spec_from_algo (algorithm);
*nbytes = spec? spec->use : 0;
break;
}
case GCRYCTL_GET_ALGO_NPKEY:
{
/* FIXME? */
int npkey = pubkey_get_npkey (algorithm);
*nbytes = npkey;
break;
}
case GCRYCTL_GET_ALGO_NSKEY:
{
/* FIXME? */
int nskey = pubkey_get_nskey (algorithm);
*nbytes = nskey;
break;
}
case GCRYCTL_GET_ALGO_NSIGN:
{
/* FIXME? */
int nsign = pubkey_get_nsig (algorithm);
*nbytes = nsign;
break;
}
case GCRYCTL_GET_ALGO_NENCR:
{
/* FIXME? */
int nencr = pubkey_get_nenc (algorithm);
*nbytes = nencr;
break;
}
default:
rc = GPG_ERR_INV_OP;
}
return rc;
}
/* Return an S-expression representing the context CTX. Depending on
the state of that context, the S-expression may either be a public
key, a private key or any other object used with public key
operations. On success a new S-expression is stored at R_SEXP and
0 is returned, on error NULL is store there and an error code is
returned. MODE is either 0 or one of the GCRY_PK_GET_xxx values.
As of now it only support certain ECC operations because a context
object is right now only defined for ECC. Over time this function
will be extended to cover more algorithms. Note also that the name
of the function is gcry_pubkey_xxx and not gcry_pk_xxx. The idea
is that we will eventually provide variants of the existing
gcry_pk_xxx functions which will take a context parameter. */
gcry_err_code_t
_gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
{
mpi_ec_t ec;
if (!r_sexp)
return GPG_ERR_INV_VALUE;
*r_sexp = NULL;
switch (mode)
{
case 0:
case GCRY_PK_GET_PUBKEY:
case GCRY_PK_GET_SECKEY:
break;
default:
return GPG_ERR_INV_VALUE;
}
if (!ctx)
return GPG_ERR_NO_CRYPT_CTX;
ec = _gcry_ctx_find_pointer (ctx, CONTEXT_TYPE_EC);
if (ec)
return _gcry_pk_ecc_get_sexp (r_sexp, mode, ec);
return GPG_ERR_WRONG_CRYPT_CTX;
}
/* Explicitly initialize this module. */
gcry_err_code_t
_gcry_pk_init (void)
{
if (fips_mode())
{
/* disable algorithms that are disallowed in fips */
int idx;
gcry_pk_spec_t *spec;
for (idx = 0; (spec = pubkey_list[idx]); idx++)
if (!spec->flags.fips)
spec->flags.disabled = 1;
}
return 0;
}
/* Run the selftests for pubkey algorithm ALGO with optional reporting
function REPORT. */
gpg_error_t
_gcry_pk_selftest (int algo, int extended, selftest_report_func_t report)
{
gcry_err_code_t ec;
gcry_pk_spec_t *spec;
algo = map_algo (algo);
spec = spec_from_algo (algo);
if (spec && !spec->flags.disabled && spec->selftest)
ec = spec->selftest (algo, extended, report);
else
{
ec = GPG_ERR_PUBKEY_ALGO;
/* Fixme: We need to change the report function to allow passing
of an encryption mode (e.g. pkcs1, ecdsa, or ecdh). */
if (report)
report ("pubkey", algo, "module",
spec && !spec->flags.disabled?
"no selftest available" :
spec? "algorithm disabled" :
"algorithm not found");
}
return gpg_error (ec);
}
struct pk_random_override {
size_t len;
unsigned char area[];
};
gpg_err_code_t
_gcry_pk_random_override_new (gcry_ctx_t *r_ctx,
const unsigned char *p, size_t len)
{
gcry_ctx_t ctx;
struct pk_random_override *pro;
*r_ctx = NULL;
if (!p)
return GPG_ERR_EINVAL;
ctx = _gcry_ctx_alloc (CONTEXT_TYPE_RANDOM_OVERRIDE,
sizeof (size_t) + len, NULL);
if (!ctx)
return gpg_err_code_from_syserror ();
pro = _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_RANDOM_OVERRIDE);
pro->len = len;
memcpy (pro->area, p, len);
*r_ctx = ctx;
return 0;
}
gpg_err_code_t
_gcry_pk_get_random_override (gcry_ctx_t ctx,
const unsigned char **r_p, size_t *r_len)
{
struct pk_random_override *pro;
pro = _gcry_ctx_find_pointer (ctx, CONTEXT_TYPE_RANDOM_OVERRIDE);
if (!pro)
return GPG_ERR_EINVAL;
*r_p = pro->area;
*r_len = pro->len;
return 0;
}
diff --git a/src/libgcrypt.def b/src/libgcrypt.def
index ddbe8cf7..a502440c 100644
--- a/src/libgcrypt.def
+++ b/src/libgcrypt.def
@@ -1,297 +1,301 @@
;; libgcrypt.defs - Exported symbols for W32
;; Copyright (C) 2003, 2007 Free Software Foundation, Inc.
;;
;; This file is part of Libgcrypt.
;;
;; Libgcrypt is free software; you can redistribute it and/or modify
;; it under the terms of the GNU Lesser General Public License as
;; published by the Free Software Foundation; either version 2.1 of
;; the License, or (at your option) any later version.
;;
;; Libgcrypt is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
;; GNU Lesser General Public License for more details.
;;
;; You should have received a copy of the GNU Lesser General Public
;; License along with this program; if not, write to the Free Software
;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
;;
;; Note: This file should be updated manually and the ordinals shall
;; never be changed. Also check libgcrypt.vers and visibility.h.
EXPORTS
gcry_check_version @1
gcry_control @2
gcry_malloc @3
gcry_calloc @4
gcry_malloc_secure @5
gcry_calloc_secure @6
gcry_realloc @7
gcry_strdup @8
gcry_xmalloc @9
gcry_xcalloc @10
gcry_xmalloc_secure @11
gcry_xcalloc_secure @12
gcry_xrealloc @13
gcry_xstrdup @14
gcry_is_secure @15
gcry_free @16
gcry_set_progress_handler @17
gcry_set_allocation_handler @18
gcry_set_outofcore_handler @19
gcry_set_fatalerror_handler @20
gcry_set_log_handler @21
gcry_set_gettext_handler @22
gcry_strerror @23
gcry_strsource @24
gcry_err_code_from_errno @25
gcry_err_code_to_errno @26
gcry_err_make_from_errno @27
gcry_error_from_errno @28
gcry_sexp_new @29
gcry_sexp_create @30
gcry_sexp_sscan @31
gcry_sexp_build @32
gcry_sexp_build_array @33
gcry_sexp_release @34
gcry_sexp_canon_len @35
gcry_sexp_sprint @36
gcry_sexp_dump @37
gcry_sexp_cons @38
gcry_sexp_alist @39
gcry_sexp_vlist @40
gcry_sexp_append @41
gcry_sexp_prepend @42
gcry_sexp_find_token @43
gcry_sexp_length @44
gcry_sexp_nth @45
gcry_sexp_car @46
gcry_sexp_cdr @47
gcry_sexp_cadr @48
gcry_sexp_nth_data @49
gcry_sexp_nth_mpi @50
gcry_mpi_new @51
gcry_mpi_snew @52
gcry_mpi_release @53
gcry_mpi_copy @54
gcry_mpi_set @55
gcry_mpi_set_ui @56
gcry_mpi_swap @57
gcry_mpi_cmp @58
gcry_mpi_cmp_ui @59
gcry_mpi_scan @60
gcry_mpi_print @61
gcry_mpi_aprint @62
gcry_mpi_dump @63
gcry_mpi_add @64
gcry_mpi_add_ui @65
gcry_mpi_addm @66
gcry_mpi_sub @67
gcry_mpi_sub_ui @68
gcry_mpi_subm @69
gcry_mpi_mul @70
gcry_mpi_mul_ui @71
gcry_mpi_mulm @72
gcry_mpi_mul_2exp @73
gcry_mpi_div @74
gcry_mpi_mod @75
gcry_mpi_powm @76
gcry_mpi_gcd @77
gcry_mpi_invm @78
gcry_mpi_get_nbits @79
gcry_mpi_test_bit @80
gcry_mpi_set_bit @81
gcry_mpi_clear_bit @82
gcry_mpi_set_highbit @83
gcry_mpi_clear_highbit @84
gcry_mpi_rshift @85
gcry_mpi_set_opaque @86
gcry_mpi_get_opaque @87
gcry_mpi_set_flag @88
gcry_mpi_clear_flag @89
gcry_mpi_get_flag @90
gcry_mpi_get_ui @91
gcry_cipher_open @92
gcry_cipher_close @93
gcry_cipher_ctl @94
gcry_cipher_info @95
gcry_cipher_algo_info @96
gcry_cipher_algo_name @97
gcry_cipher_map_name @98
gcry_cipher_mode_from_oid @99
gcry_cipher_encrypt @100
gcry_cipher_decrypt @101
gcry_cipher_get_algo_keylen @102
gcry_cipher_get_algo_blklen @103
;; @104 used to be part of the module register interface
gcry_pk_encrypt @105
gcry_pk_decrypt @106
gcry_pk_sign @107
gcry_pk_verify @108
gcry_pk_testkey @109
gcry_pk_genkey @110
gcry_pk_ctl @111
gcry_pk_algo_info @112
gcry_pk_algo_name @113
gcry_pk_map_name @114
gcry_pk_get_nbits @115
gcry_pk_get_keygrip @116
;; @117 used to be part of the module register interface
;;
;; 118 to 142 were used in previous Libgcrypt versions for the gcry_ac
;; interface
;;
gcry_md_open @143
gcry_md_close @144
gcry_md_enable @145
gcry_md_copy @146
gcry_md_reset @147
gcry_md_ctl @148
gcry_md_write @149
gcry_md_read @150
gcry_md_hash_buffer @151
gcry_md_get_algo @152
gcry_md_get_algo_dlen @153
gcry_md_is_enabled @154
gcry_md_is_secure @155
gcry_md_info @156
gcry_md_algo_info @157
gcry_md_algo_name @158
gcry_md_map_name @159
gcry_md_setkey @160
;; @161 used to be part of the module register interface
gcry_randomize @162
gcry_random_add_bytes @163
gcry_random_bytes @164
gcry_random_bytes_secure @165
gcry_mpi_randomize @166
gcry_prime_generate @167
gcry_prime_group_generator @168
gcry_prime_release_factors @169
gcry_prime_check @170
gcry_create_nonce @171
gcry_md_debug @172
;; @173 used to be part of the module register interface
;; @174 used to be part of the module register interface
;; @175 used to be part of the module register interface
;; @176 used to be part of the module register interface
;; @177 used to be part of the module register interface
;; @178 used to be part of the module register interface
;;
;; @179 to @186 used to be part of the removed gcry_ac interface
;;
gcry_sexp_nth_string @187
gcry_cipher_setkey @188
gcry_cipher_setiv @189
gcry_cipher_setctr @190
gcry_mpi_lshift @191
gcry_pk_get_curve @192
gcry_pk_get_param @193
gcry_kdf_derive @194
gcry_mpi_snatch @195
gcry_mpi_point_new @196
gcry_mpi_point_release @197
gcry_mpi_point_get @198
gcry_mpi_point_snatch_get @199
gcry_mpi_point_set @200
gcry_mpi_point_snatch_set @201
gcry_ctx_release @202
gcry_mpi_ec_new @203
gcry_mpi_ec_get_mpi @204
gcry_mpi_ec_get_point @205
gcry_mpi_ec_set_mpi @206
gcry_mpi_ec_set_point @207
gcry_mpi_ec_get_affine @208
gcry_mpi_ec_dup @209
gcry_mpi_ec_add @210
gcry_mpi_ec_mul @211
gcry_pubkey_get_sexp @212
_gcry_mpi_get_const @213
gcry_sexp_nth_buffer @214
gcry_mpi_is_neg @215
gcry_mpi_neg @216
gcry_mpi_abs @217
gcry_mpi_ec_curve_point @218
gcry_md_hash_buffers @219
gcry_log_debug @220
gcry_log_debughex @221
gcry_log_debugmpi @222
gcry_log_debugpnt @223
gcry_log_debugsxp @224
gcry_sexp_extract_param @225
gcry_cipher_authenticate @226
gcry_cipher_gettag @227
gcry_cipher_checktag @228
gcry_mpi_set_opaque_copy @229
gcry_mac_algo_info @230
gcry_mac_algo_name @231
gcry_mac_map_name @232
gcry_mac_get_algo_maclen @233
gcry_mac_get_algo_keylen @234
gcry_mac_open @235
gcry_mac_close @236
gcry_mac_setkey @237
gcry_mac_setiv @238
gcry_mac_write @239
gcry_mac_read @240
gcry_mac_verify @241
gcry_mac_ctl @242
gcry_mac_get_algo @243
gcry_mpi_ec_sub @244
gcry_md_extract @245
gcry_mpi_ec_decode_point @246
gcry_get_config @247
gcry_mpi_point_copy @248
gcry_ecc_get_algo_keylen @249
gcry_ecc_mul_point @250
gcry_pkey_open @251
gcry_pkey_ctl @252
gcry_pkey_op @253
gcry_pkey_close @254
+ gcry_pk_hash_sign @255
+ gcry_pk_hash_verify @256
+ gcry_pk_random_override_new @257
+
;; end of file with public symbols for Windows.
diff --git a/src/libgcrypt.vers b/src/libgcrypt.vers
index 81df1534..1dc07685 100644
--- a/src/libgcrypt.vers
+++ b/src/libgcrypt.vers
@@ -1,129 +1,131 @@
# libgcrypt.vers - What symbols to export -*- std -*-
# Copyright (C) 2002, 2004, 2008, 2011 Free Software Foundation, Inc.
#
# This file is part of Libgcrypt.
#
# Libgcrypt is free software; you can redistribute it and/or modify
# it under the terms of the GNU Lesser general Public License as
# published by the Free Software Foundation; either version 2.1 of
# the License, or (at your option) any later version.
#
# Libgcrypt is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
# NOTE: When adding new functions, please make sure to add them to
# visibility.h and libgcrypt.def as well.
GCRYPT_1.6 {
global:
gcry_check_version; gcry_control;
gcry_set_allocation_handler; gcry_set_fatalerror_handler;
gcry_set_gettext_handler; gcry_set_log_handler;
gcry_set_outofcore_handler; gcry_set_progress_handler;
gcry_err_code_from_errno; gcry_err_code_to_errno;
gcry_err_make_from_errno; gcry_error_from_errno;
gcry_strerror; gcry_strsource;
gcry_free; gcry_malloc; gcry_malloc_secure; gcry_calloc;
gcry_calloc_secure; gcry_realloc; gcry_strdup; gcry_is_secure;
gcry_xcalloc; gcry_xcalloc_secure; gcry_xmalloc;
gcry_xmalloc_secure; gcry_xrealloc; gcry_xstrdup;
gcry_md_algo_info; gcry_md_algo_name; gcry_md_close;
gcry_md_copy; gcry_md_ctl; gcry_md_enable; gcry_md_get;
gcry_md_get_algo; gcry_md_get_algo_dlen; gcry_md_hash_buffer;
gcry_md_hash_buffers;
gcry_md_info; gcry_md_is_enabled; gcry_md_is_secure;
gcry_md_map_name; gcry_md_open; gcry_md_read; gcry_md_extract;
gcry_md_reset; gcry_md_setkey;
gcry_md_write; gcry_md_debug;
gcry_cipher_algo_info; gcry_cipher_algo_name; gcry_cipher_close;
gcry_cipher_ctl; gcry_cipher_decrypt; gcry_cipher_encrypt;
gcry_cipher_get_algo_blklen; gcry_cipher_get_algo_keylen;
gcry_cipher_info; gcry_cipher_map_name;
gcry_cipher_mode_from_oid; gcry_cipher_open;
gcry_cipher_setkey; gcry_cipher_setiv; gcry_cipher_setctr;
gcry_cipher_authenticate; gcry_cipher_gettag; gcry_cipher_checktag;
gcry_mac_algo_info; gcry_mac_algo_name; gcry_mac_map_name;
gcry_mac_get_algo_maclen; gcry_mac_get_algo_keylen; gcry_mac_get_algo;
gcry_mac_open; gcry_mac_close; gcry_mac_setkey; gcry_mac_setiv;
gcry_mac_write; gcry_mac_read; gcry_mac_verify; gcry_mac_ctl;
gcry_pk_algo_info; gcry_pk_algo_name; gcry_pk_ctl;
gcry_pk_decrypt; gcry_pk_encrypt; gcry_pk_genkey;
gcry_pk_get_keygrip; gcry_pk_get_nbits;
gcry_pk_map_name; gcry_pk_register; gcry_pk_sign;
gcry_pk_testkey; gcry_pk_verify;
gcry_pk_get_curve; gcry_pk_get_param;
gcry_pubkey_get_sexp;
gcry_ecc_get_algo_keylen;
gcry_ecc_mul_point;
gcry_kdf_derive;
gcry_prime_check; gcry_prime_generate;
gcry_prime_group_generator; gcry_prime_release_factors;
gcry_random_add_bytes; gcry_random_bytes; gcry_random_bytes_secure;
gcry_randomize; gcry_create_nonce;
gcry_sexp_alist; gcry_sexp_append; gcry_sexp_build;
gcry_sexp_build_array; gcry_sexp_cadr; gcry_sexp_canon_len;
gcry_sexp_car; gcry_sexp_cdr; gcry_sexp_cons; gcry_sexp_create;
gcry_sexp_dump; gcry_sexp_find_token; gcry_sexp_length;
gcry_sexp_new; gcry_sexp_nth; gcry_sexp_nth_buffer; gcry_sexp_nth_data;
gcry_sexp_nth_mpi; gcry_sexp_prepend; gcry_sexp_release;
gcry_sexp_sprint; gcry_sexp_sscan; gcry_sexp_vlist;
gcry_sexp_nth_string; gcry_sexp_extract_param;
gcry_mpi_is_neg; gcry_mpi_neg; gcry_mpi_abs;
gcry_mpi_add; gcry_mpi_add_ui; gcry_mpi_addm; gcry_mpi_aprint;
gcry_mpi_clear_bit; gcry_mpi_clear_flag; gcry_mpi_clear_highbit;
gcry_mpi_cmp; gcry_mpi_cmp_ui; gcry_mpi_copy; gcry_mpi_div;
gcry_mpi_dump; gcry_mpi_gcd; gcry_mpi_get_flag; gcry_mpi_get_nbits;
gcry_mpi_get_opaque; gcry_mpi_invm; gcry_mpi_mod; gcry_mpi_mul;
gcry_mpi_mul_2exp; gcry_mpi_mul_ui; gcry_mpi_mulm; gcry_mpi_new;
gcry_mpi_powm; gcry_mpi_print; gcry_mpi_randomize; gcry_mpi_release;
gcry_mpi_rshift; gcry_mpi_scan; gcry_mpi_set; gcry_mpi_set_bit;
gcry_mpi_set_flag; gcry_mpi_set_highbit;
gcry_mpi_set_opaque; gcry_mpi_set_opaque_copy;
gcry_mpi_set_ui; gcry_mpi_snew; gcry_mpi_sub; gcry_mpi_sub_ui;
gcry_mpi_subm; gcry_mpi_swap; gcry_mpi_test_bit;
gcry_mpi_lshift; gcry_mpi_snatch;
gcry_mpi_point_new; gcry_mpi_point_release;
gcry_mpi_point_get; gcry_mpi_point_snatch_get;
gcry_mpi_point_set; gcry_mpi_point_snatch_set;
gcry_mpi_ec_new;
gcry_mpi_ec_get_mpi; gcry_mpi_ec_get_point;
gcry_mpi_ec_set_mpi; gcry_mpi_ec_set_point;
gcry_mpi_ec_get_affine;
gcry_mpi_ec_dup; gcry_mpi_ec_add; gcry_mpi_ec_sub; gcry_mpi_ec_mul;
gcry_mpi_ec_curve_point; gcry_mpi_ec_decode_point;
gcry_mpi_point_copy;
gcry_mpi_get_ui;
gcry_log_debug;
gcry_log_debughex; gcry_log_debugmpi; gcry_log_debugpnt; gcry_log_debugsxp;
gcry_get_config;
_gcry_mpi_get_const;
gcry_ctx_release;
gcry_pkey_open; gcry_pkey_ctl; gcry_pkey_op; gcry_pkey_close;
+
+ gcry_pk_hash_sign; gcry_pk_hash_verify; gcry_pk_random_override_new;
local:
*;
};
diff --git a/src/visibility.h b/src/visibility.h
index 454a8264..8a6c6258 100644
--- a/src/visibility.h
+++ b/src/visibility.h
@@ -1,531 +1,537 @@
/* visibility.h - Set visibility attribute
* Copyright (C) 2007 Free Software Foundation, Inc.
*
* This file is part of Libgcrypt.
*
* Libgcrypt is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* Libgcrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see .
*/
#ifndef GCRY_VISIBILITY_H
#define GCRY_VISIBILITY_H
/* Redefine all public symbols with an underscore unless we already
use the underscore prefixed version internally. */
/* Include the main header here so that public symbols are mapped to
the internal underscored ones. */
#ifdef _GCRY_INCLUDED_BY_VISIBILITY_C
/* We need to redeclare the deprecated functions without the
deprecated attribute. */
# define GCRYPT_NO_DEPRECATED
# include "gcrypt-int.h"
/* None in this version. */
#else
# include "gcrypt-int.h"
#endif
/* Prototypes of functions exported but not ready for use. */
gcry_err_code_t gcry_md_get (gcry_md_hd_t hd, int algo,
unsigned char *buffer, int buflen);
/* Our use of the ELF visibility feature works by passing
-fvisibiliy=hidden on the command line and by explicitly marking
all exported functions as visible.
NOTE: When adding new functions, please make sure to add them to
libgcrypt.vers and libgcrypt.def as well. */
#ifdef _GCRY_INCLUDED_BY_VISIBILITY_C
/* A macro to flag a function as visible. */
#ifdef GCRY_USE_VISIBILITY
# define MARK_VISIBLEX(name) \
extern __typeof__ (name) name __attribute__ ((visibility("default")));
#else
# define MARK_VISIBLEX(name) /* */
#endif
/* Now mark all symbols. */
MARK_VISIBLEX (gcry_check_version)
MARK_VISIBLEX (gcry_control)
MARK_VISIBLEX (gcry_set_allocation_handler)
MARK_VISIBLEX (gcry_set_fatalerror_handler)
MARK_VISIBLEX (gcry_set_gettext_handler)
MARK_VISIBLEX (gcry_set_log_handler)
MARK_VISIBLEX (gcry_set_outofcore_handler)
MARK_VISIBLEX (gcry_set_progress_handler)
MARK_VISIBLEX (gcry_err_code_from_errno)
MARK_VISIBLEX (gcry_err_code_to_errno)
MARK_VISIBLEX (gcry_err_make_from_errno)
MARK_VISIBLEX (gcry_error_from_errno)
MARK_VISIBLEX (gcry_strerror)
MARK_VISIBLEX (gcry_strsource)
MARK_VISIBLEX (gcry_malloc)
MARK_VISIBLEX (gcry_malloc_secure)
MARK_VISIBLEX (gcry_calloc)
MARK_VISIBLEX (gcry_calloc_secure)
MARK_VISIBLEX (gcry_realloc)
MARK_VISIBLEX (gcry_strdup)
MARK_VISIBLEX (gcry_is_secure)
MARK_VISIBLEX (gcry_xcalloc)
MARK_VISIBLEX (gcry_xcalloc_secure)
MARK_VISIBLEX (gcry_xmalloc)
MARK_VISIBLEX (gcry_xmalloc_secure)
MARK_VISIBLEX (gcry_xrealloc)
MARK_VISIBLEX (gcry_xstrdup)
MARK_VISIBLEX (gcry_free)
MARK_VISIBLEX (gcry_md_algo_info)
MARK_VISIBLEX (gcry_md_algo_name)
MARK_VISIBLEX (gcry_md_close)
MARK_VISIBLEX (gcry_md_copy)
MARK_VISIBLEX (gcry_md_ctl)
MARK_VISIBLEX (gcry_md_enable)
MARK_VISIBLEX (gcry_md_get)
MARK_VISIBLEX (gcry_md_get_algo)
MARK_VISIBLEX (gcry_md_get_algo_dlen)
MARK_VISIBLEX (gcry_md_hash_buffer)
MARK_VISIBLEX (gcry_md_hash_buffers)
MARK_VISIBLEX (gcry_md_info)
MARK_VISIBLEX (gcry_md_is_enabled)
MARK_VISIBLEX (gcry_md_is_secure)
MARK_VISIBLEX (gcry_md_map_name)
MARK_VISIBLEX (gcry_md_open)
MARK_VISIBLEX (gcry_md_read)
MARK_VISIBLEX (gcry_md_extract)
MARK_VISIBLEX (gcry_md_reset)
MARK_VISIBLEX (gcry_md_setkey)
MARK_VISIBLEX (gcry_md_write)
MARK_VISIBLEX (gcry_md_debug)
MARK_VISIBLEX (gcry_cipher_algo_info)
MARK_VISIBLEX (gcry_cipher_algo_name)
MARK_VISIBLEX (gcry_cipher_close)
MARK_VISIBLEX (gcry_cipher_setkey)
MARK_VISIBLEX (gcry_cipher_setiv)
MARK_VISIBLEX (gcry_cipher_setctr)
MARK_VISIBLEX (gcry_cipher_authenticate)
MARK_VISIBLEX (gcry_cipher_checktag)
MARK_VISIBLEX (gcry_cipher_gettag)
MARK_VISIBLEX (gcry_cipher_ctl)
MARK_VISIBLEX (gcry_cipher_decrypt)
MARK_VISIBLEX (gcry_cipher_encrypt)
MARK_VISIBLEX (gcry_cipher_get_algo_blklen)
MARK_VISIBLEX (gcry_cipher_get_algo_keylen)
MARK_VISIBLEX (gcry_cipher_info)
MARK_VISIBLEX (gcry_cipher_map_name)
MARK_VISIBLEX (gcry_cipher_mode_from_oid)
MARK_VISIBLEX (gcry_cipher_open)
MARK_VISIBLEX (gcry_mac_algo_info)
MARK_VISIBLEX (gcry_mac_algo_name)
MARK_VISIBLEX (gcry_mac_map_name)
MARK_VISIBLEX (gcry_mac_get_algo)
MARK_VISIBLEX (gcry_mac_get_algo_maclen)
MARK_VISIBLEX (gcry_mac_get_algo_keylen)
MARK_VISIBLEX (gcry_mac_open)
MARK_VISIBLEX (gcry_mac_close)
MARK_VISIBLEX (gcry_mac_setkey)
MARK_VISIBLEX (gcry_mac_setiv)
MARK_VISIBLEX (gcry_mac_write)
MARK_VISIBLEX (gcry_mac_read)
MARK_VISIBLEX (gcry_mac_verify)
MARK_VISIBLEX (gcry_mac_ctl)
MARK_VISIBLEX (gcry_pk_algo_info)
MARK_VISIBLEX (gcry_pk_algo_name)
MARK_VISIBLEX (gcry_pk_ctl)
MARK_VISIBLEX (gcry_pk_decrypt)
MARK_VISIBLEX (gcry_pk_encrypt)
MARK_VISIBLEX (gcry_pk_genkey)
MARK_VISIBLEX (gcry_pk_get_keygrip)
MARK_VISIBLEX (gcry_pk_get_curve)
MARK_VISIBLEX (gcry_pk_get_param)
MARK_VISIBLEX (gcry_pk_get_nbits)
MARK_VISIBLEX (gcry_pk_map_name)
MARK_VISIBLEX (gcry_pk_sign)
MARK_VISIBLEX (gcry_pk_testkey)
MARK_VISIBLEX (gcry_pk_verify)
MARK_VISIBLEX (gcry_pubkey_get_sexp)
MARK_VISIBLEX (gcry_ecc_get_algo_keylen)
MARK_VISIBLEX (gcry_ecc_mul_point)
+MARK_VISIBLEX (gcry_pk_hash_sign)
+MARK_VISIBLEX (gcry_pk_hash_verify)
+MARK_VISIBLEX (gcry_pk_random_override_new)
MARK_VISIBLEX (gcry_pkey_open)
MARK_VISIBLEX (gcry_pkey_op)
MARK_VISIBLEX (gcry_pkey_ctl)
MARK_VISIBLEX (gcry_pkey_close)
MARK_VISIBLEX (gcry_kdf_derive)
MARK_VISIBLEX (gcry_prime_check)
MARK_VISIBLEX (gcry_prime_generate)
MARK_VISIBLEX (gcry_prime_group_generator)
MARK_VISIBLEX (gcry_prime_release_factors)
MARK_VISIBLEX (gcry_random_add_bytes)
MARK_VISIBLEX (gcry_random_bytes)
MARK_VISIBLEX (gcry_random_bytes_secure)
MARK_VISIBLEX (gcry_randomize)
MARK_VISIBLEX (gcry_create_nonce)
MARK_VISIBLEX (gcry_sexp_alist)
MARK_VISIBLEX (gcry_sexp_append)
MARK_VISIBLEX (gcry_sexp_build)
MARK_VISIBLEX (gcry_sexp_build_array)
MARK_VISIBLEX (gcry_sexp_cadr)
MARK_VISIBLEX (gcry_sexp_canon_len)
MARK_VISIBLEX (gcry_sexp_car)
MARK_VISIBLEX (gcry_sexp_cdr)
MARK_VISIBLEX (gcry_sexp_cons)
MARK_VISIBLEX (gcry_sexp_create)
MARK_VISIBLEX (gcry_sexp_dump)
MARK_VISIBLEX (gcry_sexp_find_token)
MARK_VISIBLEX (gcry_sexp_length)
MARK_VISIBLEX (gcry_sexp_new)
MARK_VISIBLEX (gcry_sexp_nth)
MARK_VISIBLEX (gcry_sexp_nth_buffer)
MARK_VISIBLEX (gcry_sexp_nth_data)
MARK_VISIBLEX (gcry_sexp_nth_mpi)
MARK_VISIBLEX (gcry_sexp_nth_string)
MARK_VISIBLEX (gcry_sexp_prepend)
MARK_VISIBLEX (gcry_sexp_release)
MARK_VISIBLEX (gcry_sexp_sprint)
MARK_VISIBLEX (gcry_sexp_sscan)
MARK_VISIBLEX (gcry_sexp_vlist)
MARK_VISIBLEX (gcry_sexp_extract_param)
MARK_VISIBLEX (gcry_mpi_abs)
MARK_VISIBLEX (gcry_mpi_add)
MARK_VISIBLEX (gcry_mpi_add_ui)
MARK_VISIBLEX (gcry_mpi_addm)
MARK_VISIBLEX (gcry_mpi_aprint)
MARK_VISIBLEX (gcry_mpi_clear_bit)
MARK_VISIBLEX (gcry_mpi_clear_flag)
MARK_VISIBLEX (gcry_mpi_clear_highbit)
MARK_VISIBLEX (gcry_mpi_cmp)
MARK_VISIBLEX (gcry_mpi_cmp_ui)
MARK_VISIBLEX (gcry_mpi_copy)
MARK_VISIBLEX (gcry_mpi_div)
MARK_VISIBLEX (gcry_mpi_dump)
MARK_VISIBLEX (gcry_mpi_ec_add)
MARK_VISIBLEX (gcry_mpi_ec_sub)
MARK_VISIBLEX (gcry_mpi_ec_curve_point)
MARK_VISIBLEX (gcry_mpi_ec_dup)
MARK_VISIBLEX (gcry_mpi_ec_decode_point)
MARK_VISIBLEX (gcry_mpi_ec_get_affine)
MARK_VISIBLEX (gcry_mpi_ec_mul)
MARK_VISIBLEX (gcry_mpi_ec_new)
MARK_VISIBLEX (gcry_mpi_ec_get_mpi)
MARK_VISIBLEX (gcry_mpi_ec_get_point)
MARK_VISIBLEX (gcry_mpi_ec_set_mpi)
MARK_VISIBLEX (gcry_mpi_ec_set_point)
MARK_VISIBLEX (gcry_mpi_gcd)
MARK_VISIBLEX (gcry_mpi_get_flag)
MARK_VISIBLEX (gcry_mpi_get_nbits)
MARK_VISIBLEX (gcry_mpi_get_opaque)
MARK_VISIBLEX (gcry_mpi_is_neg)
MARK_VISIBLEX (gcry_mpi_invm)
MARK_VISIBLEX (gcry_mpi_mod)
MARK_VISIBLEX (gcry_mpi_mul)
MARK_VISIBLEX (gcry_mpi_mul_2exp)
MARK_VISIBLEX (gcry_mpi_mul_ui)
MARK_VISIBLEX (gcry_mpi_mulm)
MARK_VISIBLEX (gcry_mpi_neg)
MARK_VISIBLEX (gcry_mpi_new)
MARK_VISIBLEX (gcry_mpi_point_get)
MARK_VISIBLEX (gcry_mpi_point_new)
MARK_VISIBLEX (gcry_mpi_point_release)
MARK_VISIBLEX (gcry_mpi_point_copy)
MARK_VISIBLEX (gcry_mpi_point_set)
MARK_VISIBLEX (gcry_mpi_point_snatch_get)
MARK_VISIBLEX (gcry_mpi_point_snatch_set)
MARK_VISIBLEX (gcry_mpi_powm)
MARK_VISIBLEX (gcry_mpi_print)
MARK_VISIBLEX (gcry_mpi_randomize)
MARK_VISIBLEX (gcry_mpi_release)
MARK_VISIBLEX (gcry_mpi_rshift)
MARK_VISIBLEX (gcry_mpi_lshift)
MARK_VISIBLEX (gcry_mpi_scan)
MARK_VISIBLEX (gcry_mpi_snatch)
MARK_VISIBLEX (gcry_mpi_set)
MARK_VISIBLEX (gcry_mpi_set_bit)
MARK_VISIBLEX (gcry_mpi_set_flag)
MARK_VISIBLEX (gcry_mpi_set_highbit)
MARK_VISIBLEX (gcry_mpi_set_opaque)
MARK_VISIBLEX (gcry_mpi_set_opaque_copy)
MARK_VISIBLEX (gcry_mpi_set_ui)
MARK_VISIBLEX (gcry_mpi_get_ui)
MARK_VISIBLEX (gcry_mpi_snew)
MARK_VISIBLEX (gcry_mpi_sub)
MARK_VISIBLEX (gcry_mpi_sub_ui)
MARK_VISIBLEX (gcry_mpi_subm)
MARK_VISIBLEX (gcry_mpi_swap)
MARK_VISIBLEX (gcry_mpi_test_bit)
MARK_VISIBLEX (gcry_ctx_release)
MARK_VISIBLEX (gcry_log_debug)
MARK_VISIBLEX (gcry_log_debughex)
MARK_VISIBLEX (gcry_log_debugmpi)
MARK_VISIBLEX (gcry_log_debugpnt)
MARK_VISIBLEX (gcry_log_debugsxp)
MARK_VISIBLEX (gcry_get_config)
/* Functions used to implement macros. */
MARK_VISIBLEX (_gcry_mpi_get_const)
#undef MARK_VISIBLEX
#else /*!_GCRY_INCLUDED_BY_VISIBILITY_C*/
/* To avoid accidental use of the public functions inside Libgcrypt,
we redefine them to catch such errors. The usual difference
between a public and an internal version is that the internal
version use gpg_err_code_t and the public version gpg_error_t. */
#define gcry_check_version _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_control _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_allocation_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_fatalerror_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_gettext_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_log_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_outofcore_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_set_progress_handler _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_err_code_from_errno _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_err_code_to_errno _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_err_make_from_errno _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_error_from_errno _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_strerror _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_strsource _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_malloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_malloc_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_calloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_calloc_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_realloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_strdup _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xcalloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xcalloc_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xmalloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xmalloc_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xrealloc _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_xstrdup _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_free _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_is_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_open _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_close _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_setkey _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_setiv _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_setctr _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_algo_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_algo_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_authenticate _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_checktag _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_gettag _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_ctl _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_decrypt _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_encrypt _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_get_algo_blklen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_get_algo_keylen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_map_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_cipher_mode_from_oid _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_algo_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_algo_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_ctl _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_decrypt _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_encrypt _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_genkey _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_get_keygrip _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_get_curve _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_get_param _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_get_nbits _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_map_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_sign _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_testkey _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pk_verify _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pubkey_get_sexp _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_ecc_get_algo_keylen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_ecc_mul_point _gcry_USE_THE_UNDERSCORED_FUNCTION
+#define gcry_pk_hash_sign _gcry_USE_THE_UNDERSCORED_FUNCTION
+#define gcry_pk_hash_verify _gcry_USE_THE_UNDERSCORED_FUNCTION
+#define gcry_pk_random_override_new _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pkey_open _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pkey_ctl _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pkey_op _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_pkey_open _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_algo_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_algo_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_close _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_copy _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_ctl _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_enable _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_get _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_get_algo _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_get_algo_dlen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_hash_buffer _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_hash_buffers _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_is_enabled _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_is_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_map_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_open _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_read _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_extract _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_reset _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_setkey _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_write _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_md_debug _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_algo_info _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_algo_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_map_name _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_get_algo _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_get_algo_maclen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_get_algo_keylen _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_open _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_close _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_setkey _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_setiv _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_write _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_read _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_verify _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mac_ctl _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_kdf_derive _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_prime_check _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_prime_generate _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_prime_group_generator _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_prime_release_factors _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_random_add_bytes _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_random_bytes _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_random_bytes_secure _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_randomize _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_create_nonce _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_ctx_release _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_alist _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_append _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_build _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_build_array _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_cadr _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_canon_len _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_car _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_cdr _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_cons _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_create _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_dump _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_find_token _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_length _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_new _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_nth _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_nth_buffer _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_nth_data _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_nth_mpi _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_nth_string _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_prepend _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_release _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_sprint _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_sscan _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_vlist _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_sexp_extract_param _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_add _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_add_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_addm _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_aprint _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_clear_bit _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_clear_flag _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_clear_highbit _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_cmp _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_cmp_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_copy _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_div _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_dump _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_gcd _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_get_flag _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_get_nbits _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_get_opaque _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_invm _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_mod _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_mul _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_mul_2exp _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_mul_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_mulm _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_new _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_get _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_new _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_release _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_copy _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_set _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_snatch_get _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_point_snatch_set _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_powm _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_print _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_randomize _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_release _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_rshift _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_lshift _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_scan _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_bit _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_flag _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_highbit _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_opaque _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_get_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_snatch _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_snew _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_sub _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_sub_ui _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_subm _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_swap _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_test_bit _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_abs _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_add _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_sub _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_curve_point _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_dup _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_decode_point _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_get_affine _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_get_mpi _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_get_point _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_mul _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_new _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_set_mpi _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_ec_set_point _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_is_neg _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_neg _gcry_USE_THE_UNDERSCORED_FUNCTION
#define gcry_mpi_set_opaque_copy _gcry_USE_THE_UNDERSCORED_FUNCTION
#endif /*!_GCRY_INCLUDED_BY_VISIBILITY_C*/
#endif /*GCRY_VISIBILITY_H*/