Remove macro hacks for internal vs. external functions. Part 1.
authorWerner Koch <wk@gnupg.org>
Tue, 22 Oct 2013 12:26:53 +0000 (14:26 +0200)
committerWerner Koch <wk@gnupg.org>
Thu, 5 Dec 2013 07:27:48 +0000 (08:27 +0100)
* src/visibility.h: Remove almost all define/undef hacks for symbol
visibility.  Add macros to detect the use of the public functions.
Change all affected functions by prefixing them explicitly with an
underscore and change all internal callers to call the underscore
prefixed versions.  Provide convenience macros from sexp and mpi
functions.
* src/visibility.c: Change all functions to use only gpg_err_code_t
and translate to gpg_error_t only in visibility.c.
--

The use of the macro magic made if hard to follow the function calls
in the source.  It was not easy to see if an internal or external
function (as defined by visibility.c) was called.  The change is quite
large but hopefully makes  Libgcrypt easier to maintain.  Some
function have not yet been fixed; this will be done soon.

Because Libgcrypt does no make use of any other libgpg-error using
libraries it is useless to always translate between gpg_error_t and
gpg_err_code_t (i.e with and w/o error source identifier).  This
translation has no mostly be moved to the function wrappers in
visibility.c.  An additional advantage of using gpg_err_code_t is that
comparison can be done without using gpg_err_code().

I am sorry for that large patch, but a series of patches would
actually be more work to audit.

Signed-off-by: Werner Koch <wk@gnupg.org>
49 files changed:
cipher/cipher.c
cipher/dsa-common.c
cipher/dsa.c
cipher/ecc-common.h
cipher/ecc-curves.c
cipher/ecc-ecdsa.c
cipher/ecc-eddsa.c
cipher/ecc-gost.c
cipher/ecc-misc.c
cipher/ecc.c
cipher/elgamal.c
cipher/hmac-tests.c
cipher/kdf.c
cipher/mac-cmac.c
cipher/mac-gmac.c
cipher/mac-hmac.c
cipher/mac.c
cipher/md.c
cipher/primegen.c
cipher/pubkey-util.c
cipher/pubkey.c
cipher/rsa-common.c
cipher/rsa.c
mpi/ec.c
mpi/mpi-add.c
mpi/mpi-bit.c
mpi/mpi-cmp.c
mpi/mpi-div.c
mpi/mpi-gcd.c
mpi/mpi-inv.c
mpi/mpi-mod.c
mpi/mpi-mpow.c
mpi/mpi-mul.c
mpi/mpi-pow.c
mpi/mpicoder.c
mpi/mpiutil.c
random/random-daemon.c
random/random-fips.c
random/random.c
src/cipher-proto.h
src/context.c
src/g10lib.h
src/gcrypt-int.h
src/global.c
src/misc.c
src/mpi.h
src/sexp.c
src/visibility.c
src/visibility.h

index 516f44b..f7f5a46 100644 (file)
@@ -197,7 +197,7 @@ search_oid (const char *oid, gcry_cipher_oid_spec_t *oid_spec)
    not known.  It is valid to pass NULL for STRING which results in a
    return value of 0. */
 int
    not known.  It is valid to pass NULL for STRING which results in a
    return value of 0. */
 int
-gcry_cipher_map_name (const char *string)
+_gcry_cipher_map_name (const char *string)
 {
   gcry_cipher_spec_t *spec;
 
 {
   gcry_cipher_spec_t *spec;
 
@@ -225,7 +225,7 @@ gcry_cipher_map_name (const char *string)
    with that OID or 0 if no mode is known.  Passing NULL for string
    yields a return value of 0. */
 int
    with that OID or 0 if no mode is known.  Passing NULL for string
    yields a return value of 0. */
 int
-gcry_cipher_mode_from_oid (const char *string)
+_gcry_cipher_mode_from_oid (const char *string)
 {
   gcry_cipher_spec_t *spec;
   gcry_cipher_oid_spec_t oid_spec;
 {
   gcry_cipher_spec_t *spec;
   gcry_cipher_oid_spec_t oid_spec;
@@ -246,7 +246,7 @@ gcry_cipher_mode_from_oid (const char *string)
    used by Libgcrypt.  A "?" is returned for an unknown algorithm.
    NULL is never returned. */
 const char *
    used by Libgcrypt.  A "?" is returned for an unknown algorithm.
    NULL is never returned. */
 const char *
-gcry_cipher_algo_name (int algorithm)
+_gcry_cipher_algo_name (int algorithm)
 {
   gcry_cipher_spec_t *spec;
 
 {
   gcry_cipher_spec_t *spec;
 
@@ -340,21 +340,21 @@ cipher_get_blocksize (int algorithm)
 
    Values for these flags may be combined using OR.
  */
 
    Values for these flags may be combined using OR.
  */
-gcry_error_t
-gcry_cipher_open (gcry_cipher_hd_t *handle,
-                 int algo, int mode, unsigned int flags)
+gcry_err_code_t
+_gcry_cipher_open (gcry_cipher_hd_t *handle,
+                   int algo, int mode, unsigned int flags)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
   gcry_cipher_hd_t h = NULL;
 
   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
   gcry_cipher_hd_t h = NULL;
 
   if (mode >= GCRY_CIPHER_MODE_INTERNAL)
-    err = GPG_ERR_INV_CIPHER_MODE;
+    rc = GPG_ERR_INV_CIPHER_MODE;
   else
   else
-    err = _gcry_cipher_open_internal (&h, algo, mode, flags);
+    rc = _gcry_cipher_open_internal (&h, algo, mode, flags);
 
 
-  *handle = err ? NULL : h;
+  *handle = rc ? NULL : h;
 
 
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -545,7 +545,7 @@ _gcry_cipher_open_internal (gcry_cipher_hd_t *handle,
 /* Release all resources associated with the cipher handle H. H may be
    NULL in which case this is a no-operation. */
 void
 /* Release all resources associated with the cipher handle H. H may be
    NULL in which case this is a no-operation. */
 void
-gcry_cipher_close (gcry_cipher_hd_t h)
+_gcry_cipher_close (gcry_cipher_hd_t h)
 {
   size_t off;
 
 {
   size_t off;
 
@@ -574,13 +574,13 @@ gcry_cipher_close (gcry_cipher_hd_t h)
 
 /* Set the key to be used for the encryption context C to KEY with
    length KEYLEN.  The length should match the required length. */
 
 /* Set the key to be used for the encryption context C to KEY with
    length KEYLEN.  The length should match the required length. */
-static gcry_error_t
+static gcry_err_code_t
 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
 {
 cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
 {
-  gcry_err_code_t ret;
+  gcry_err_code_t rc;
 
 
-  ret = c->spec->setkey (&c->context.c, key, keylen);
-  if (!ret)
+  rc = c->spec->setkey (&c->context.c, key, keylen);
+  if (!rc)
     {
       /* Duplicate initial context.  */
       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
     {
       /* Duplicate initial context.  */
       memcpy ((void *) ((char *) &c->context.c + c->spec->contextsize),
@@ -605,7 +605,7 @@ cipher_setkey (gcry_cipher_hd_t c, byte *key, size_t keylen)
   else
     c->marks.key = 0;
 
   else
     c->marks.key = 0;
 
-  return gcry_error (ret);
+  return rc;
 }
 
 
 }
 
 
@@ -830,11 +830,11 @@ cipher_encrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
  * been requested.
  */
  * Encrypt IN and write it to OUT.  If IN is NULL, in-place encryption has
  * been requested.
  */
-gcry_error_t
-gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
-                     const void *in, size_t inlen)
+gcry_err_code_t
+_gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
+                      const void *in, size_t inlen)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
 
   if (!in)  /* Caller requested in-place encryption.  */
     {
 
   if (!in)  /* Caller requested in-place encryption.  */
     {
@@ -842,14 +842,14 @@ gcry_cipher_encrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
       inlen = outsize;
     }
 
       inlen = outsize;
     }
 
-  err = cipher_encrypt (h, out, outsize, in, inlen);
+  rc = cipher_encrypt (h, out, outsize, in, inlen);
 
   /* Failsafe: Make sure that the plaintext will never make it into
      OUT if the encryption returned an error.  */
 
   /* Failsafe: Make sure that the plaintext will never make it into
      OUT if the encryption returned an error.  */
-  if (err && out)
+  if (rc && out)
     memset (out, 0x42, outsize);
 
     memset (out, 0x42, outsize);
 
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -934,21 +934,17 @@ cipher_decrypt (gcry_cipher_hd_t c, byte *outbuf, size_t outbuflen,
 }
 
 
 }
 
 
-gcry_error_t
-gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
-                    const void *in, size_t inlen)
+gcry_err_code_t
+_gcry_cipher_decrypt (gcry_cipher_hd_t h, void *out, size_t outsize,
+                      const void *in, size_t inlen)
 {
 {
-  gcry_err_code_t err;
-
   if (!in) /* Caller requested in-place encryption. */
     {
       in = out;
       inlen = outsize;
     }
 
   if (!in) /* Caller requested in-place encryption. */
     {
       in = out;
       inlen = outsize;
     }
 
-  err = cipher_decrypt (h, out, outsize, in, inlen);
-
-  return gcry_error (err);
+  return cipher_decrypt (h, out, outsize, in, inlen);
 }
 
 
 }
 
 
@@ -971,17 +967,17 @@ cipher_sync (gcry_cipher_hd_t c)
 }
 
 
 }
 
 
-gcry_error_t
+gcry_err_code_t
 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
 {
   return cipher_setkey (hd, (void*)key, keylen);
 }
 
 
 _gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
 {
   return cipher_setkey (hd, (void*)key, keylen);
 }
 
 
-gcry_error_t
+gcry_err_code_t
 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
 {
 _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
 {
-  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
 
   switch (hd->mode)
     {
 
   switch (hd->mode)
     {
@@ -993,13 +989,13 @@ _gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
         rc = cipher_setiv (hd, iv, ivlen);
         break;
     }
         rc = cipher_setiv (hd, iv, ivlen);
         break;
     }
-  return gpg_error (rc);
+  return rc;
 }
 
 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
    block size length, or (NULL,0) to set the CTR to the all-zero
    block. */
 }
 
 /* Set counter for CTR mode.  (CTR,CTRLEN) must denote a buffer of
    block size length, or (NULL,0) to set the CTR to the all-zero
    block. */
-gpg_error_t
+gpg_err_code_t
 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
 {
   if (ctr && ctrlen == hd->spec->blocksize)
 _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
 {
   if (ctr && ctrlen == hd->spec->blocksize)
@@ -1013,11 +1009,13 @@ _gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
       hd->unused = 0;
     }
   else
       hd->unused = 0;
     }
   else
-    return gpg_error (GPG_ERR_INV_ARG);
+    return GPG_ERR_INV_ARG;
+
   return 0;
 }
 
   return 0;
 }
 
-gcry_error_t
+
+gcry_err_code_t
 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
                            size_t abuflen)
 {
 _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
                            size_t abuflen)
 {
@@ -1043,10 +1041,11 @@ _gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf,
       break;
     }
 
       break;
     }
 
-  return gpg_error (rc);
+  return rc;
 }
 
 }
 
-gcry_error_t
+
+gcry_err_code_t
 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
 {
   gcry_err_code_t rc;
 _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
 {
   gcry_err_code_t rc;
@@ -1071,10 +1070,11 @@ _gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
       break;
     }
 
       break;
     }
 
-  return gpg_error (rc);
+  return rc;
 }
 
 }
 
-gcry_error_t
+
+gcry_err_code_t
 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
 {
   gcry_err_code_t rc;
 _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
 {
   gcry_err_code_t rc;
@@ -1099,14 +1099,14 @@ _gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
       break;
     }
 
       break;
     }
 
-  return gpg_error (rc);
+  return rc;
 }
 
 
 }
 
 
-gcry_error_t
-gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
+gcry_err_code_t
+_gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
 {
 {
-  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
 
   switch (cmd)
     {
 
   switch (cmd)
     {
@@ -1206,7 +1206,7 @@ gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
       rc = GPG_ERR_INV_OP;
     }
 
       rc = GPG_ERR_INV_OP;
     }
 
-  return gcry_error (rc);
+  return rc;
 }
 
 
 }
 
 
@@ -1218,10 +1218,10 @@ gcry_cipher_ctl( gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
    The function always returns GPG_ERR_INV_OP.
 
  */
    The function always returns GPG_ERR_INV_OP.
 
  */
-gcry_error_t
-gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
+gcry_err_code_t
+_gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
 {
 {
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
 
   (void)h;
   (void)buffer;
 
   (void)h;
   (void)buffer;
@@ -1230,10 +1230,10 @@ gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
   switch (cmd)
     {
     default:
   switch (cmd)
     {
     default:
-      err = GPG_ERR_INV_OP;
+      rc = GPG_ERR_INV_OP;
     }
 
     }
 
-  return gcry_error (err);
+  return rc;
 }
 
 /* Return information about the given cipher algorithm ALGO.
 }
 
 /* Return information about the given cipher algorithm ALGO.
@@ -1260,17 +1260,17 @@ gcry_cipher_info (gcry_cipher_hd_t h, int cmd, void *buffer, size_t *nbytes)
    and thereby detecting whether a error occurred or not (i.e. while
    checking the block size)
  */
    and thereby detecting whether a error occurred or not (i.e. while
    checking the block size)
  */
-gcry_error_t
-gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
+gcry_err_code_t
+_gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
 {
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
   unsigned int ui;
 
   switch (what)
     {
     case GCRYCTL_GET_KEYLEN:
       if (buffer || (! nbytes))
   unsigned int ui;
 
   switch (what)
     {
     case GCRYCTL_GET_KEYLEN:
       if (buffer || (! nbytes))
-       err = GPG_ERR_CIPHER_ALGO;
+       rc = GPG_ERR_CIPHER_ALGO;
       else
        {
          ui = cipher_get_keylen (algo);
       else
        {
          ui = cipher_get_keylen (algo);
@@ -1278,37 +1278,39 @@ gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
            *nbytes = (size_t) ui / 8;
          else
            /* The only reason for an error is an invalid algo.  */
            *nbytes = (size_t) ui / 8;
          else
            /* The only reason for an error is an invalid algo.  */
-           err = GPG_ERR_CIPHER_ALGO;
+           rc = GPG_ERR_CIPHER_ALGO;
        }
       break;
 
     case GCRYCTL_GET_BLKLEN:
       if (buffer || (! nbytes))
        }
       break;
 
     case GCRYCTL_GET_BLKLEN:
       if (buffer || (! nbytes))
-       err = GPG_ERR_CIPHER_ALGO;
+       rc = GPG_ERR_CIPHER_ALGO;
       else
        {
          ui = cipher_get_blocksize (algo);
          if ((ui > 0) && (ui < 10000))
            *nbytes = ui;
          else
       else
        {
          ui = cipher_get_blocksize (algo);
          if ((ui > 0) && (ui < 10000))
            *nbytes = ui;
          else
-           /* The only reason is an invalid algo or a strange
-              blocksize.  */
-           err = GPG_ERR_CIPHER_ALGO;
+            {
+              /* The only reason is an invalid algo or a strange
+                 blocksize.  */
+              rc = GPG_ERR_CIPHER_ALGO;
+            }
        }
       break;
 
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
        }
       break;
 
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
-       err = GPG_ERR_INV_ARG;
+       rc = GPG_ERR_INV_ARG;
       else
       else
-       err = check_cipher_algo (algo);
+       rc = check_cipher_algo (algo);
       break;
 
       default:
       break;
 
       default:
-       err = GPG_ERR_INV_OP;
+       rc = GPG_ERR_INV_OP;
     }
 
     }
 
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -1321,15 +1323,16 @@ gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
    gcry_cipher_algo_info because it allows for proper type
    checking.  */
 size_t
    gcry_cipher_algo_info because it allows for proper type
    checking.  */
 size_t
-gcry_cipher_get_algo_keylen (int algo)
+_gcry_cipher_get_algo_keylen (int algo)
 {
   size_t n;
 
 {
   size_t n;
 
-  if (gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
+  if (_gcry_cipher_algo_info (algo, GCRYCTL_GET_KEYLEN, NULL, &n))
     n = 0;
   return n;
 }
 
     n = 0;
   return n;
 }
 
+
 /* This functions returns the blocklength of the algorithm ALGO
    counted in octets.  On error 0 is returned.
 
 /* This functions returns the blocklength of the algorithm ALGO
    counted in octets.  On error 0 is returned.
 
@@ -1337,15 +1340,16 @@ gcry_cipher_get_algo_keylen (int algo)
    gcry_cipher_algo_info because it allows for proper type
    checking.  */
 size_t
    gcry_cipher_algo_info because it allows for proper type
    checking.  */
 size_t
-gcry_cipher_get_algo_blklen (int algo)
+_gcry_cipher_get_algo_blklen (int algo)
 {
   size_t n;
 
 {
   size_t n;
 
-  if (gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
+  if (_gcry_cipher_algo_info( algo, GCRYCTL_GET_BLKLEN, NULL, &n))
     n = 0;
   return n;
 }
 
     n = 0;
   return n;
 }
 
+
 /* Explicitly initialize this module.  */
 gcry_err_code_t
 _gcry_cipher_init (void)
 /* Explicitly initialize this module.  */
 gcry_err_code_t
 _gcry_cipher_init (void)
index c5386b7..da29dd3 100644 (file)
@@ -54,7 +54,7 @@ _gcry_dsa_gen_k (gcry_mpi_t q, int security_level)
       if ( !rndbuf || nbits < 32 )
         {
           gcry_free (rndbuf);
       if ( !rndbuf || nbits < 32 )
         {
           gcry_free (rndbuf);
-          rndbuf = gcry_random_bytes_secure (nbytes, security_level);
+          rndbuf = _gcry_random_bytes_secure (nbytes, security_level);
        }
       else
         { /* Change only some of the higher bits.  We could improve
        }
       else
         { /* Change only some of the higher bits.  We could improve
@@ -62,7 +62,7 @@ _gcry_dsa_gen_k (gcry_mpi_t q, int security_level)
             to get_random_bytes() and use these extra bytes here.
             However the required management code is more complex and
             thus we better use this simple method.  */
             to get_random_bytes() and use these extra bytes here.
             However the required management code is more complex and
             thus we better use this simple method.  */
-          char *pp = gcry_random_bytes_secure (4, security_level);
+          char *pp = _gcry_random_bytes_secure (4, security_level);
           memcpy (rndbuf, pp, 4);
           gcry_free (pp);
        }
           memcpy (rndbuf, pp, 4);
           gcry_free (pp);
        }
@@ -112,8 +112,7 @@ int2octets (unsigned char **r_frame, gcry_mpi_t value, size_t nbytes)
   size_t nframe, noff, n;
   unsigned char *frame;
 
   size_t nframe, noff, n;
   unsigned char *frame;
 
-  rc = gpg_err_code (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0,
-                                      &nframe, value));
+  rc = _gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &nframe, value);
   if (rc)
     return rc;
   if (nframe > nbytes)
   if (rc)
     return rc;
   if (nframe > nbytes)
@@ -127,8 +126,7 @@ int2octets (unsigned char **r_frame, gcry_mpi_t value, size_t nbytes)
   if (noff)
     memset (frame, 0, noff);
   nframe += noff;
   if (noff)
     memset (frame, 0, noff);
   nframe += noff;
-  rc = gpg_err_code (gcry_mpi_print (GCRYMPI_FMT_USG, frame+noff, nframe-noff,
-                                      NULL, value));
+  rc = _gcry_mpi_print (GCRYMPI_FMT_USG, frame+noff, nframe-noff, NULL, value);
   if (rc)
     {
       gcry_free (frame);
   if (rc)
     {
       gcry_free (frame);
@@ -152,12 +150,11 @@ bits2octets (unsigned char **r_frame,
   gcry_mpi_t z1;
 
   /* z1 = bits2int (b) */
   gcry_mpi_t z1;
 
   /* z1 = bits2int (b) */
-  rc = gpg_err_code (gcry_mpi_scan (&z1, GCRYMPI_FMT_USG,
-                                    bits, (nbits+7)/8, NULL));
+  rc = _gcry_mpi_scan (&z1, GCRYMPI_FMT_USG, bits, (nbits+7)/8, NULL);
   if (rc)
     return rc;
   if (nbits > qbits)
   if (rc)
     return rc;
   if (nbits > qbits)
-    gcry_mpi_rshift (z1, z1, nbits - qbits);
+    mpi_rshift (z1, z1, nbits - qbits);
 
   /* z2 - z1 mod q */
   if (mpi_cmp (z1, q) >= 0)
 
   /* z2 - z1 mod q */
   if (mpi_cmp (z1, q) >= 0)
@@ -199,7 +196,7 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
   if (!qbits || !h1 || !hlen)
     return GPG_ERR_EINVAL;
 
   if (!qbits || !h1 || !hlen)
     return GPG_ERR_EINVAL;
 
-  if (gcry_md_get_algo_dlen (halgo) != hlen)
+  if (_gcry_md_get_algo_dlen (halgo) != hlen)
     return GPG_ERR_DIGEST_ALGO;
 
   /* Step b:  V = 0x01 0x01 0x01 ... 0x01 */
     return GPG_ERR_DIGEST_ALGO;
 
   /* Step b:  V = 0x01 0x01 0x01 ... 0x01 */
@@ -229,44 +226,43 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
     goto leave;
 
   /* Create a handle to compute the HMACs.  */
     goto leave;
 
   /* Create a handle to compute the HMACs.  */
-  rc = gpg_err_code (gcry_md_open (&hd, halgo,
-                                   (GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC)));
+  rc = _gcry_md_open (&hd, halgo, (GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC));
   if (rc)
     goto leave;
 
   /* Step d:  K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) */
   if (rc)
     goto leave;
 
   /* Step d:  K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) */
-  rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+  rc = _gcry_md_setkey (hd, K, hlen);
   if (rc)
     goto leave;
   if (rc)
     goto leave;
-  gcry_md_write (hd, V, hlen);
-  gcry_md_write (hd, "", 1);
-  gcry_md_write (hd, x_buf, (qbits+7)/8);
-  gcry_md_write (hd, h1_buf, (qbits+7)/8);
-  memcpy (K, gcry_md_read (hd, 0), hlen);
+  _gcry_md_write (hd, V, hlen);
+  _gcry_md_write (hd, "", 1);
+  _gcry_md_write (hd, x_buf, (qbits+7)/8);
+  _gcry_md_write (hd, h1_buf, (qbits+7)/8);
+  memcpy (K, _gcry_md_read (hd, 0), hlen);
 
   /* Step e:  V = HMAC_K(V) */
 
   /* Step e:  V = HMAC_K(V) */
-  rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+  rc = _gcry_md_setkey (hd, K, hlen);
   if (rc)
     goto leave;
   if (rc)
     goto leave;
-  gcry_md_write (hd, V, hlen);
-  memcpy (V, gcry_md_read (hd, 0), hlen);
+  _gcry_md_write (hd, V, hlen);
+  memcpy (V, _gcry_md_read (hd, 0), hlen);
 
   /* Step f:  K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1) */
 
   /* Step f:  K = HMAC_K(V || 0x01 || int2octets(x) || bits2octets(h1) */
-  rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+  rc = _gcry_md_setkey (hd, K, hlen);
   if (rc)
     goto leave;
   if (rc)
     goto leave;
-  gcry_md_write (hd, V, hlen);
-  gcry_md_write (hd, "\x01", 1);
-  gcry_md_write (hd, x_buf, (qbits+7)/8);
-  gcry_md_write (hd, h1_buf, (qbits+7)/8);
-  memcpy (K, gcry_md_read (hd, 0), hlen);
+  _gcry_md_write (hd, V, hlen);
+  _gcry_md_write (hd, "\x01", 1);
+  _gcry_md_write (hd, x_buf, (qbits+7)/8);
+  _gcry_md_write (hd, h1_buf, (qbits+7)/8);
+  memcpy (K, _gcry_md_read (hd, 0), hlen);
 
   /* Step g:  V = HMAC_K(V) */
 
   /* Step g:  V = HMAC_K(V) */
-  rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+  rc = _gcry_md_setkey (hd, K, hlen);
   if (rc)
     goto leave;
   if (rc)
     goto leave;
-  gcry_md_write (hd, V, hlen);
-  memcpy (V, gcry_md_read (hd, 0), hlen);
+  _gcry_md_write (hd, V, hlen);
+  memcpy (V, _gcry_md_read (hd, 0), hlen);
 
   /* Step h. */
   t = gcry_malloc ((qbits+7)/8+hlen);
 
   /* Step h. */
   t = gcry_malloc ((qbits+7)/8+hlen);
@@ -280,11 +276,11 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
   for (tbits = 0; tbits < qbits;)
     {
       /* V = HMAC_K(V) */
   for (tbits = 0; tbits < qbits;)
     {
       /* V = HMAC_K(V) */
-      rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+      rc = _gcry_md_setkey (hd, K, hlen);
       if (rc)
         goto leave;
       if (rc)
         goto leave;
-      gcry_md_write (hd, V, hlen);
-      memcpy (V, gcry_md_read (hd, 0), hlen);
+      _gcry_md_write (hd, V, hlen);
+      memcpy (V, _gcry_md_read (hd, 0), hlen);
 
       /* T = T || V */
       memcpy (t+(tbits+7)/8, V, hlen);
 
       /* T = T || V */
       memcpy (t+(tbits+7)/8, V, hlen);
@@ -294,29 +290,29 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
   /* k = bits2int (T) */
   mpi_free (k);
   k = NULL;
   /* k = bits2int (T) */
   mpi_free (k);
   k = NULL;
-  rc = gpg_err_code (gcry_mpi_scan (&k, GCRYMPI_FMT_USG, t, (tbits+7)/8, NULL));
+  rc = _gcry_mpi_scan (&k, GCRYMPI_FMT_USG, t, (tbits+7)/8, NULL);
   if (rc)
     goto leave;
   if (tbits > qbits)
   if (rc)
     goto leave;
   if (tbits > qbits)
-    gcry_mpi_rshift (k, k, tbits - qbits);
+    mpi_rshift (k, k, tbits - qbits);
 
   /* Check: k < q and k > 1 */
   if (!(mpi_cmp (k, dsa_q) < 0 && mpi_cmp_ui (k, 0) > 0))
     {
       /* K = HMAC_K(V || 0x00) */
 
   /* Check: k < q and k > 1 */
   if (!(mpi_cmp (k, dsa_q) < 0 && mpi_cmp_ui (k, 0) > 0))
     {
       /* K = HMAC_K(V || 0x00) */
-      rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+      rc = _gcry_md_setkey (hd, K, hlen);
       if (rc)
         goto leave;
       if (rc)
         goto leave;
-      gcry_md_write (hd, V, hlen);
-      gcry_md_write (hd, "", 1);
-      memcpy (K, gcry_md_read (hd, 0), hlen);
+      _gcry_md_write (hd, V, hlen);
+      _gcry_md_write (hd, "", 1);
+      memcpy (K, _gcry_md_read (hd, 0), hlen);
 
       /* V = HMAC_K(V) */
 
       /* V = HMAC_K(V) */
-      rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+      rc = _gcry_md_setkey (hd, K, hlen);
       if (rc)
         goto leave;
       if (rc)
         goto leave;
-      gcry_md_write (hd, V, hlen);
-      memcpy (V, gcry_md_read (hd, 0), hlen);
+      _gcry_md_write (hd, V, hlen);
+      memcpy (V, _gcry_md_read (hd, 0), hlen);
 
       goto again;
     }
 
       goto again;
     }
@@ -330,19 +326,19 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
       extraloops--;
 
       /* K = HMAC_K(V || 0x00) */
       extraloops--;
 
       /* K = HMAC_K(V || 0x00) */
-      rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+      rc = _gcry_md_setkey (hd, K, hlen);
       if (rc)
         goto leave;
       if (rc)
         goto leave;
-      gcry_md_write (hd, V, hlen);
-      gcry_md_write (hd, "", 1);
-      memcpy (K, gcry_md_read (hd, 0), hlen);
+      _gcry_md_write (hd, V, hlen);
+      _gcry_md_write (hd, "", 1);
+      memcpy (K, _gcry_md_read (hd, 0), hlen);
 
       /* V = HMAC_K(V) */
 
       /* V = HMAC_K(V) */
-      rc = gpg_err_code (gcry_md_setkey (hd, K, hlen));
+      rc = _gcry_md_setkey (hd, K, hlen);
       if (rc)
         goto leave;
       if (rc)
         goto leave;
-      gcry_md_write (hd, V, hlen);
-      memcpy (V, gcry_md_read (hd, 0), hlen);
+      _gcry_md_write (hd, V, hlen);
+      memcpy (V, _gcry_md_read (hd, 0), hlen);
 
       goto again;
     }
 
       goto again;
     }
@@ -351,7 +347,7 @@ _gcry_dsa_gen_rfc6979_k (gcry_mpi_t *r_k,
 
  leave:
   gcry_free (t);
 
  leave:
   gcry_free (t);
-  gcry_md_close (hd);
+  _gcry_md_close (hd);
   gcry_free (h1_buf);
   gcry_free (x_buf);
   gcry_free (K);
   gcry_free (h1_buf);
   gcry_free (x_buf);
   gcry_free (K);
index 45ad97a..d5ff5ba 100644 (file)
@@ -148,9 +148,9 @@ test_keys (DSA_secret_key *sk, unsigned int qbits)
 {
   int result = -1;  /* Default to failure.  */
   DSA_public_key pk;
 {
   int result = -1;  /* Default to failure.  */
   DSA_public_key pk;
-  gcry_mpi_t data  = gcry_mpi_new (qbits);
-  gcry_mpi_t sig_a = gcry_mpi_new (qbits);
-  gcry_mpi_t sig_b = gcry_mpi_new (qbits);
+  gcry_mpi_t data  = mpi_new (qbits);
+  gcry_mpi_t sig_a = mpi_new (qbits);
+  gcry_mpi_t sig_b = mpi_new (qbits);
 
   /* Put the relevant parameters into a public key structure.  */
   pk.p = sk->p;
 
   /* Put the relevant parameters into a public key structure.  */
   pk.p = sk->p;
@@ -159,7 +159,7 @@ test_keys (DSA_secret_key *sk, unsigned int qbits)
   pk.y = sk->y;
 
   /* Create a random plaintext.  */
   pk.y = sk->y;
 
   /* Create a random plaintext.  */
-  gcry_mpi_randomize (data, qbits, GCRY_WEAK_RANDOM);
+  _gcry_mpi_randomize (data, qbits, GCRY_WEAK_RANDOM);
 
   /* Sign DATA using the secret key.  */
   sign (sig_a, sig_b, data, sk, 0, 0);
 
   /* Sign DATA using the secret key.  */
   sign (sig_a, sig_b, data, sk, 0, 0);
@@ -169,16 +169,16 @@ test_keys (DSA_secret_key *sk, unsigned int qbits)
     goto leave; /* Signature does not match.  */
 
   /* Modify the data and check that the signing fails.  */
     goto leave; /* Signature does not match.  */
 
   /* Modify the data and check that the signing fails.  */
-  gcry_mpi_add_ui (data, data, 1);
+  mpi_add_ui (data, data, 1);
   if ( verify (sig_a, sig_b, data, &pk) )
     goto leave; /* Signature matches but should not.  */
 
   result = 0; /* The test succeeded.  */
 
  leave:
   if ( verify (sig_a, sig_b, data, &pk) )
     goto leave; /* Signature matches but should not.  */
 
   result = 0; /* The test succeeded.  */
 
  leave:
-  gcry_mpi_release (sig_b);
-  gcry_mpi_release (sig_a);
-  gcry_mpi_release (data);
+  _gcry_mpi_release (sig_b);
+  _gcry_mpi_release (sig_a);
+  _gcry_mpi_release (data);
   return result;
 }
 
   return result;
 }
 
@@ -263,7 +263,7 @@ generate (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
         {
           mpi_add_ui (h, h, 1);
           /* g = h^e mod p */
         {
           mpi_add_ui (h, h, 1);
           /* g = h^e mod p */
-          gcry_mpi_powm (g, h, e, p);
+          mpi_powm (g, h, e, p);
         }
       while (!mpi_cmp_ui (g, 1));  /* Continue until g != 1. */
     }
         }
       while (!mpi_cmp_ui (g, 1));  /* Continue until g != 1. */
     }
@@ -291,10 +291,10 @@ generate (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
       if( DBG_CIPHER )
         progress('.');
       if( !rndbuf )
       if( DBG_CIPHER )
         progress('.');
       if( !rndbuf )
-        rndbuf = gcry_random_bytes_secure ((qbits+7)/8, random_level);
+        rndbuf = _gcry_random_bytes_secure ((qbits+7)/8, random_level);
       else
         { /* Change only some of the higher bits (= 2 bytes)*/
       else
         { /* Change only some of the higher bits (= 2 bytes)*/
-          char *r = gcry_random_bytes_secure (2, random_level);
+          char *r = _gcry_random_bytes_secure (2, random_level);
           memcpy(rndbuf, r, 2 );
           gcry_free(r);
         }
           memcpy(rndbuf, r, 2 );
           gcry_free(r);
         }
@@ -309,7 +309,7 @@ generate (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
 
   /* y = g^x mod p */
   y = mpi_alloc( mpi_get_nlimbs(p) );
 
   /* y = g^x mod p */
   y = mpi_alloc( mpi_get_nlimbs(p) );
-  gcry_mpi_powm( y, g, x, p );
+  mpi_powm (y, g, x, p);
 
   if( DBG_CIPHER )
     {
 
   if( DBG_CIPHER )
     {
@@ -331,11 +331,11 @@ generate (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
   /* Now we can test our keys (this should never fail!). */
   if ( test_keys (sk, qbits) )
     {
   /* Now we can test our keys (this should never fail!). */
   if ( test_keys (sk, qbits) )
     {
-      gcry_mpi_release (sk->p); sk->p = NULL;
-      gcry_mpi_release (sk->q); sk->q = NULL;
-      gcry_mpi_release (sk->g); sk->g = NULL;
-      gcry_mpi_release (sk->y); sk->y = NULL;
-      gcry_mpi_release (sk->x); sk->x = NULL;
+      _gcry_mpi_release (sk->p); sk->p = NULL;
+      _gcry_mpi_release (sk->q); sk->q = NULL;
+      _gcry_mpi_release (sk->g); sk->g = NULL;
+      _gcry_mpi_release (sk->y); sk->y = NULL;
+      _gcry_mpi_release (sk->x); sk->x = NULL;
       fips_signal_error ("self-test after key generation failed");
       return GPG_ERR_SELFTEST_FAILED;
     }
       fips_signal_error ("self-test after key generation failed");
       return GPG_ERR_SELFTEST_FAILED;
     }
@@ -418,9 +418,9 @@ generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
       /* Get an initial seed value.  */
       if (deriveparms)
         {
       /* Get an initial seed value.  */
       if (deriveparms)
         {
-          initial_seed.sexp = gcry_sexp_find_token (deriveparms, "seed", 0);
+          initial_seed.sexp = sexp_find_token (deriveparms, "seed", 0);
           if (initial_seed.sexp)
           if (initial_seed.sexp)
-            initial_seed.seed = gcry_sexp_nth_data (initial_seed.sexp, 1,
+            initial_seed.seed = sexp_nth_data (initial_seed.sexp, 1,
                                                     &initial_seed.seedlen);
         }
 
                                                     &initial_seed.seedlen);
         }
 
@@ -439,7 +439,7 @@ generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
       /*                                          &prime_q, &prime_p, */
       /*                                          r_counter, */
       /*                                          r_seed, r_seedlen, NULL); */
       /*                                          &prime_q, &prime_p, */
       /*                                          r_counter, */
       /*                                          r_seed, r_seedlen, NULL); */
-      gcry_sexp_release (initial_seed.sexp);
+      sexp_release (initial_seed.sexp);
       if (ec)
         goto leave;
 
       if (ec)
         goto leave;
 
@@ -461,19 +461,19 @@ generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
 
 
   /* Select a random number x with:  0 < x < q  */
 
 
   /* Select a random number x with:  0 < x < q  */
-  value_x = gcry_mpi_snew (qbits);
+  value_x = mpi_snew (qbits);
   do
     {
       if( DBG_CIPHER )
         progress('.');
   do
     {
       if( DBG_CIPHER )
         progress('.');
-      gcry_mpi_randomize (value_x, qbits, GCRY_VERY_STRONG_RANDOM);
+      _gcry_mpi_randomize (value_x, qbits, GCRY_VERY_STRONG_RANDOM);
       mpi_clear_highbit (value_x, qbits+1);
     }
   while (!(mpi_cmp_ui (value_x, 0) > 0 && mpi_cmp (value_x, prime_q) < 0));
 
   /* y = g^x mod p */
   value_y = mpi_alloc_like (prime_p);
       mpi_clear_highbit (value_x, qbits+1);
     }
   while (!(mpi_cmp_ui (value_x, 0) > 0 && mpi_cmp (value_x, prime_q) < 0));
 
   /* y = g^x mod p */
   value_y = mpi_alloc_like (prime_p);
-  gcry_mpi_powm (value_y, value_g, value_x, prime_p);
+  mpi_powm (value_y, value_g, value_x, prime_p);
 
   if (DBG_CIPHER)
     {
 
   if (DBG_CIPHER)
     {
@@ -495,22 +495,22 @@ generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
   *r_h = value_h; value_h = NULL;
 
  leave:
   *r_h = value_h; value_h = NULL;
 
  leave:
-  gcry_mpi_release (prime_p);
-  gcry_mpi_release (prime_q);
-  gcry_mpi_release (value_g);
-  gcry_mpi_release (value_y);
-  gcry_mpi_release (value_x);
-  gcry_mpi_release (value_h);
-  gcry_mpi_release (value_e);
+  _gcry_mpi_release (prime_p);
+  _gcry_mpi_release (prime_q);
+  _gcry_mpi_release (value_g);
+  _gcry_mpi_release (value_y);
+  _gcry_mpi_release (value_x);
+  _gcry_mpi_release (value_h);
+  _gcry_mpi_release (value_e);
 
   /* As a last step test this keys (this should never fail of course). */
   if (!ec && test_keys (sk, qbits) )
     {
 
   /* As a last step test this keys (this should never fail of course). */
   if (!ec && test_keys (sk, qbits) )
     {
-      gcry_mpi_release (sk->p); sk->p = NULL;
-      gcry_mpi_release (sk->q); sk->q = NULL;
-      gcry_mpi_release (sk->g); sk->g = NULL;
-      gcry_mpi_release (sk->y); sk->y = NULL;
-      gcry_mpi_release (sk->x); sk->x = NULL;
+      _gcry_mpi_release (sk->p); sk->p = NULL;
+      _gcry_mpi_release (sk->q); sk->q = NULL;
+      _gcry_mpi_release (sk->g); sk->g = NULL;
+      _gcry_mpi_release (sk->y); sk->y = NULL;
+      _gcry_mpi_release (sk->x); sk->x = NULL;
       fips_signal_error ("self-test after key generation failed");
       ec = GPG_ERR_SELFTEST_FAILED;
     }
       fips_signal_error ("self-test after key generation failed");
       ec = GPG_ERR_SELFTEST_FAILED;
     }
@@ -520,7 +520,7 @@ generate_fips186 (DSA_secret_key *sk, unsigned int nbits, unsigned int qbits,
       *r_counter = 0;
       gcry_free (*r_seed); *r_seed = NULL;
       *r_seedlen = 0;
       *r_counter = 0;
       gcry_free (*r_seed); *r_seed = NULL;
       *r_seedlen = 0;
-      gcry_mpi_release (*r_h); *r_h = NULL;
+      _gcry_mpi_release (*r_h); *r_h = NULL;
     }
 
   return ec;
     }
 
   return ec;
@@ -538,7 +538,7 @@ check_secret_key( DSA_secret_key *sk )
   int rc;
   gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
   int rc;
   gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
-  gcry_mpi_powm( y, sk->g, sk->x, sk->p );
+  mpi_powm( y, sk->g, sk->x, sk->p );
   rc = !mpi_cmp( y, sk->y );
   mpi_free( y );
   return rc;
   rc = !mpi_cmp( y, sk->y );
   mpi_free( y );
   return rc;
@@ -575,13 +575,12 @@ sign (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input, DSA_secret_key *skey,
   /* Convert the INPUT into an MPI.  */
   if (mpi_is_opaque (input))
     {
   /* Convert the INPUT into an MPI.  */
   if (mpi_is_opaque (input))
     {
-      abuf = gcry_mpi_get_opaque (input, &abits);
-      rc = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
-                                        abuf, (abits+7)/8, NULL));
+      abuf = mpi_get_opaque (input, &abits);
+      rc = _gcry_mpi_scan (&hash, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
       if (rc)
         return rc;
       if (abits > qbits)
       if (rc)
         return rc;
       if (abits > qbits)
-        gcry_mpi_rshift (hash, hash, abits - qbits);
+        mpi_rshift (hash, hash, abits - qbits);
     }
   else
     hash = input;
     }
   else
     hash = input;
@@ -599,7 +598,7 @@ sign (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input, DSA_secret_key *skey,
           goto leave;
         }
 
           goto leave;
         }
 
-      abuf = gcry_mpi_get_opaque (input, &abits);
+      abuf = mpi_get_opaque (input, &abits);
       rc = _gcry_dsa_gen_rfc6979_k (&k, skey->q, skey->x,
                                     abuf, (abits+7)/8, hashalgo, extraloops);
       if (rc)
       rc = _gcry_dsa_gen_rfc6979_k (&k, skey->q, skey->x,
                                     abuf, (abits+7)/8, hashalgo, extraloops);
       if (rc)
@@ -612,7 +611,7 @@ sign (gcry_mpi_t r, gcry_mpi_t s, gcry_mpi_t input, DSA_secret_key *skey,
     }
 
   /* r = (a^k mod p) mod q */
     }
 
   /* r = (a^k mod p) mod q */
-  gcry_mpi_powm( r, skey->g, k, skey->p );
+  mpi_powm( r, skey->g, k, skey->p );
   mpi_fdiv_r( r, r, skey->q );
 
   /* kinv = k^(-1) mod q */
   mpi_fdiv_r( r, r, skey->q );
 
   /* kinv = k^(-1) mod q */
@@ -722,71 +721,71 @@ dsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
     return rc;
 
   /* Parse the optional flags list.  */
     return rc;
 
   /* Parse the optional flags list.  */
-  l1 = gcry_sexp_find_token (genparms, "flags", 0);
+  l1 = sexp_find_token (genparms, "flags", 0);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
-      gcry_sexp_release (l1);
+      sexp_release (l1);
       if (rc)
         return rc;\
     }
 
   /* Parse the optional qbits element.  */
       if (rc)
         return rc;\
     }
 
   /* Parse the optional qbits element.  */
-  l1 = gcry_sexp_find_token (genparms, "qbits", 0);
+  l1 = sexp_find_token (genparms, "qbits", 0);
   if (l1)
     {
       char buf[50];
       const char *s;
       size_t n;
 
   if (l1)
     {
       char buf[50];
       const char *s;
       size_t n;
 
-      s = gcry_sexp_nth_data (l1, 1, &n);
+      s = sexp_nth_data (l1, 1, &n);
       if (!s || n >= DIM (buf) - 1 )
         {
       if (!s || n >= DIM (buf) - 1 )
         {
-          gcry_sexp_release (l1);
+          sexp_release (l1);
           return GPG_ERR_INV_OBJ; /* No value or value too large.  */
         }
       memcpy (buf, s, n);
       buf[n] = 0;
       qbits = (unsigned int)strtoul (buf, NULL, 0);
           return GPG_ERR_INV_OBJ; /* No value or value too large.  */
         }
       memcpy (buf, s, n);
       buf[n] = 0;
       qbits = (unsigned int)strtoul (buf, NULL, 0);
-      gcry_sexp_release (l1);
+      sexp_release (l1);
     }
 
   /* Parse the optional transient-key flag.  */
   if (!(flags & PUBKEY_FLAG_TRANSIENT_KEY))
     {
     }
 
   /* Parse the optional transient-key flag.  */
   if (!(flags & PUBKEY_FLAG_TRANSIENT_KEY))
     {
-      l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
+      l1 = sexp_find_token (genparms, "transient-key", 0);
       if (l1)
         {
           flags |= PUBKEY_FLAG_TRANSIENT_KEY;
       if (l1)
         {
           flags |= PUBKEY_FLAG_TRANSIENT_KEY;
-          gcry_sexp_release (l1);
+          sexp_release (l1);
         }
     }
 
   /* Get the optional derive parameters.  */
         }
     }
 
   /* Get the optional derive parameters.  */
-  deriveparms = gcry_sexp_find_token (genparms, "derive-parms", 0);
+  deriveparms = sexp_find_token (genparms, "derive-parms", 0);
 
   /* Parse the optional "use-fips186" flags.  */
   if (!(flags & PUBKEY_FLAG_USE_FIPS186))
     {
 
   /* Parse the optional "use-fips186" flags.  */
   if (!(flags & PUBKEY_FLAG_USE_FIPS186))
     {
-      l1 = gcry_sexp_find_token (genparms, "use-fips186", 0);
+      l1 = sexp_find_token (genparms, "use-fips186", 0);
       if (l1)
         {
           flags |= PUBKEY_FLAG_USE_FIPS186;
       if (l1)
         {
           flags |= PUBKEY_FLAG_USE_FIPS186;
-          gcry_sexp_release (l1);
+          sexp_release (l1);
         }
     }
   if (!(flags & PUBKEY_FLAG_USE_FIPS186_2))
     {
         }
     }
   if (!(flags & PUBKEY_FLAG_USE_FIPS186_2))
     {
-      l1 = gcry_sexp_find_token (genparms, "use-fips186-2", 0);
+      l1 = sexp_find_token (genparms, "use-fips186-2", 0);
       if (l1)
         {
           flags |= PUBKEY_FLAG_USE_FIPS186_2;
       if (l1)
         {
           flags |= PUBKEY_FLAG_USE_FIPS186_2;
-          gcry_sexp_release (l1);
+          sexp_release (l1);
         }
     }
 
   /* Check whether domain parameters are given.  */
         }
     }
 
   /* Check whether domain parameters are given.  */
-  domainsexp = gcry_sexp_find_token (genparms, "domain", 0);
+  domainsexp = sexp_find_token (genparms, "domain", 0);
   if (domainsexp)
     {
       /* DERIVEPARMS can't be used together with domain parameters.
   if (domainsexp)
     {
       /* DERIVEPARMS can't be used together with domain parameters.
@@ -794,30 +793,30 @@ dsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
          are derived from the domain parameters.  */
       if (deriveparms || qbits || nbits)
         {
          are derived from the domain parameters.  */
       if (deriveparms || qbits || nbits)
         {
-          gcry_sexp_release (domainsexp);
-          gcry_sexp_release (deriveparms);
+          sexp_release (domainsexp);
+          sexp_release (deriveparms);
           return GPG_ERR_INV_VALUE;
         }
 
       /* Put all domain parameters into the domain object.  */
           return GPG_ERR_INV_VALUE;
         }
 
       /* Put all domain parameters into the domain object.  */
-      l1 = gcry_sexp_find_token (domainsexp, "p", 0);
-      domain.p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-      gcry_sexp_release (l1);
-      l1 = gcry_sexp_find_token (domainsexp, "q", 0);
-      domain.q = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-      gcry_sexp_release (l1);
-      l1 = gcry_sexp_find_token (domainsexp, "g", 0);
-      domain.g = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-      gcry_sexp_release (l1);
-      gcry_sexp_release (domainsexp);
+      l1 = sexp_find_token (domainsexp, "p", 0);
+      domain.p = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+      sexp_release (l1);
+      l1 = sexp_find_token (domainsexp, "q", 0);
+      domain.q = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+      sexp_release (l1);
+      l1 = sexp_find_token (domainsexp, "g", 0);
+      domain.g = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+      sexp_release (l1);
+      sexp_release (domainsexp);
 
       /* Check that all domain parameters are available.  */
       if (!domain.p || !domain.q || !domain.g)
         {
 
       /* Check that all domain parameters are available.  */
       if (!domain.p || !domain.q || !domain.g)
         {
-          gcry_mpi_release (domain.p);
-          gcry_mpi_release (domain.q);
-          gcry_mpi_release (domain.g);
-          gcry_sexp_release (deriveparms);
+          _gcry_mpi_release (domain.p);
+          _gcry_mpi_release (domain.q);
+          _gcry_mpi_release (domain.g);
+          sexp_release (deriveparms);
           return GPG_ERR_MISSING_VALUE;
         }
 
           return GPG_ERR_MISSING_VALUE;
         }
 
@@ -844,11 +843,11 @@ dsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
         {
           /* Format the seed-values unless domain parameters are used
              for which a H_VALUE of NULL is an indication.  */
         {
           /* Format the seed-values unless domain parameters are used
              for which a H_VALUE of NULL is an indication.  */
-          rc = gcry_sexp_build (&seedinfo, NULL,
-                                "(seed-values(counter %d)(seed %b)(h %m))",
-                                counter, (int)seedlen, seed, h_value);
+          rc = sexp_build (&seedinfo, NULL,
+                           "(seed-values(counter %d)(seed %b)(h %m))",
+                           counter, (int)seedlen, seed, h_value);
           gcry_free (seed);
           gcry_free (seed);
-          gcry_mpi_release (h_value);
+          _gcry_mpi_release (h_value);
         }
     }
   else
         }
     }
   else
@@ -904,7 +903,7 @@ dsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
                 arg_list[i++] = factors + j;
               arg_list[i] = NULL;
 
                 arg_list[i++] = factors + j;
               arg_list[i] = NULL;
 
-              rc = gcry_sexp_build_array (&misc_info, NULL, format, arg_list);
+              rc = sexp_build_array (&misc_info, NULL, format, arg_list);
             }
         }
 
             }
         }
 
@@ -913,31 +912,31 @@ dsa_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
     }
 
   if (!rc)
     }
 
   if (!rc)
-    rc = gcry_sexp_build (r_skey, NULL,
-                          "(key-data"
-                          " (public-key"
-                          "  (dsa(p%m)(q%m)(g%m)(y%m)))"
-                          " (private-key"
-                          "  (dsa(p%m)(q%m)(g%m)(y%m)(x%m)))"
-                          " %S)",
-                          sk.p, sk.q, sk.g, sk.y,
-                          sk.p, sk.q, sk.g, sk.y, sk.x,
-                          misc_info);
-
-
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.q);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
-
-  gcry_mpi_release (domain.p);
-  gcry_mpi_release (domain.q);
-  gcry_mpi_release (domain.g);
-
-  gcry_sexp_release (seedinfo);
-  gcry_sexp_release (misc_info);
-  gcry_sexp_release (deriveparms);
+    rc = sexp_build (r_skey, NULL,
+                     "(key-data"
+                     " (public-key"
+                     "  (dsa(p%m)(q%m)(g%m)(y%m)))"
+                     " (private-key"
+                     "  (dsa(p%m)(q%m)(g%m)(y%m)(x%m)))"
+                     " %S)",
+                     sk.p, sk.q, sk.g, sk.y,
+                     sk.p, sk.q, sk.g, sk.y, sk.x,
+                     misc_info);
+
+
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.q);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
+
+  _gcry_mpi_release (domain.p);
+  _gcry_mpi_release (domain.q);
+  _gcry_mpi_release (domain.g);
+
+  sexp_release (seedinfo);
+  sexp_release (misc_info);
+  sexp_release (deriveparms);
   if (factors)
     {
       gcry_mpi_t *mp;
   if (factors)
     {
       gcry_mpi_t *mp;
@@ -966,11 +965,11 @@ dsa_check_secret_key (gcry_sexp_t keyparms)
     rc = GPG_ERR_BAD_SECKEY;
 
  leave:
     rc = GPG_ERR_BAD_SECKEY;
 
  leave:
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.q);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.q);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
   if (DBG_CIPHER)
     log_debug ("dsa_testkey    => %s\n", gpg_strerror (rc));
   return rc;
   if (DBG_CIPHER)
     log_debug ("dsa_testkey    => %s\n", gpg_strerror (rc));
   return rc;
@@ -1012,8 +1011,8 @@ dsa_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         log_mpidump ("dsa_sign      x", sk.x);
     }
 
         log_mpidump ("dsa_sign      x", sk.x);
     }
 
-  sig_r = gcry_mpi_new (0);
-  sig_s = gcry_mpi_new (0);
+  sig_r = mpi_new (0);
+  sig_s = mpi_new (0);
   rc = sign (sig_r, sig_s, data, &sk, ctx.flags, ctx.hash_algo);
   if (rc)
     goto leave;
   rc = sign (sig_r, sig_s, data, &sk, ctx.flags, ctx.hash_algo);
   if (rc)
     goto leave;
@@ -1022,17 +1021,17 @@ dsa_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
       log_mpidump ("dsa_sign  sig_r", sig_r);
       log_mpidump ("dsa_sign  sig_s", sig_s);
     }
       log_mpidump ("dsa_sign  sig_r", sig_r);
       log_mpidump ("dsa_sign  sig_s", sig_s);
     }
-  rc = gcry_sexp_build (r_sig, NULL, "(sig-val(dsa(r%M)(s%M)))", sig_r, sig_s);
+  rc = sexp_build (r_sig, NULL, "(sig-val(dsa(r%M)(s%M)))", sig_r, sig_s);
 
  leave:
 
  leave:
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.q);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
-  gcry_mpi_release (data);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.q);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
+  _gcry_mpi_release (data);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("dsa_sign      => %s\n", gpg_strerror (rc));
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("dsa_sign      => %s\n", gpg_strerror (rc));
@@ -1096,17 +1095,16 @@ dsa_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
 
       qbits = mpi_get_nbits (pk.q);
 
 
       qbits = mpi_get_nbits (pk.q);
 
-      abuf = gcry_mpi_get_opaque (data, &abits);
-      rc = gpg_err_code (gcry_mpi_scan (&a, GCRYMPI_FMT_USG,
-                                        abuf, (abits+7)/8, NULL));
+      abuf = mpi_get_opaque (data, &abits);
+      rc = _gcry_mpi_scan (&a, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
       if (!rc)
         {
           if (abits > qbits)
       if (!rc)
         {
           if (abits > qbits)
-            gcry_mpi_rshift (a, a, abits - qbits);
+            mpi_rshift (a, a, abits - qbits);
 
           if (!verify (sig_r, sig_s, a, &pk))
             rc = GPG_ERR_BAD_SIGNATURE;
 
           if (!verify (sig_r, sig_s, a, &pk))
             rc = GPG_ERR_BAD_SIGNATURE;
-          gcry_mpi_release (a);
+          _gcry_mpi_release (a);
         }
     }
   else
         }
     }
   else
@@ -1116,14 +1114,14 @@ dsa_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
     }
 
  leave:
     }
 
  leave:
-  gcry_mpi_release (pk.p);
-  gcry_mpi_release (pk.q);
-  gcry_mpi_release (pk.g);
-  gcry_mpi_release (pk.y);
-  gcry_mpi_release (data);
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
-  gcry_sexp_release (l1);
+  _gcry_mpi_release (pk.p);
+  _gcry_mpi_release (pk.q);
+  _gcry_mpi_release (pk.g);
+  _gcry_mpi_release (pk.y);
+  _gcry_mpi_release (data);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
+  sexp_release (l1);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("dsa_verify    => %s\n", rc?gpg_strerror (rc):"Good");
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("dsa_verify    => %s\n", rc?gpg_strerror (rc):"Good");
@@ -1150,14 +1148,14 @@ dsa_get_nbits (gcry_sexp_t parms)
   gcry_mpi_t p;
   unsigned int nbits;
 
   gcry_mpi_t p;
   unsigned int nbits;
 
-  l1 = gcry_sexp_find_token (parms, "p", 1);
+  l1 = sexp_find_token (parms, "p", 1);
   if (!l1)
     return 0; /* Parameter P not found.  */
 
   if (!l1)
     return 0; /* Parameter P not found.  */
 
-  p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-  gcry_sexp_release (l1);
+  p = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+  sexp_release (l1);
   nbits = p? mpi_get_nbits (p) : 0;
   nbits = p? mpi_get_nbits (p) : 0;
-  gcry_mpi_release (p);
+  _gcry_mpi_release (p);
   return nbits;
 }
 
   return nbits;
 }
 
@@ -1183,30 +1181,29 @@ selftest_sign_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
   gcry_sexp_t data_bad = NULL;
   gcry_sexp_t sig = NULL;
 
   gcry_sexp_t data_bad = NULL;
   gcry_sexp_t sig = NULL;
 
-  err = gcry_sexp_sscan (&data, NULL,
-                         sample_data, strlen (sample_data));
+  err = sexp_sscan (&data, NULL, sample_data, strlen (sample_data));
   if (!err)
   if (!err)
-    err = gcry_sexp_sscan (&data_bad, NULL,
-                           sample_data_bad, strlen (sample_data_bad));
+    err = sexp_sscan (&data_bad, NULL,
+                      sample_data_bad, strlen (sample_data_bad));
   if (err)
     {
       errtxt = "converting data failed";
       goto leave;
     }
 
   if (err)
     {
       errtxt = "converting data failed";
       goto leave;
     }
 
-  err = gcry_pk_sign (&sig, data, skey);
+  err = _gcry_pk_sign (&sig, data, skey);
   if (err)
     {
       errtxt = "signing failed";
       goto leave;
     }
   if (err)
     {
       errtxt = "signing failed";
       goto leave;
     }
-  err = gcry_pk_verify (sig, data, pkey);
+  err = _gcry_pk_verify (sig, data, pkey);
   if (err)
     {
       errtxt = "verify failed";
       goto leave;
     }
   if (err)
     {
       errtxt = "verify failed";
       goto leave;
     }
-  err = gcry_pk_verify (sig, data_bad, pkey);
+  err = _gcry_pk_verify (sig, data_bad, pkey);
   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
     {
       errtxt = "bad signature not detected";
   if (gcry_err_code (err) != GPG_ERR_BAD_SIGNATURE)
     {
       errtxt = "bad signature not detected";
@@ -1215,9 +1212,9 @@ selftest_sign_1024 (gcry_sexp_t pkey, gcry_sexp_t skey)
 
 
  leave:
 
 
  leave:
-  gcry_sexp_release (sig);
-  gcry_sexp_release (data_bad);
-  gcry_sexp_release (data);
+  sexp_release (sig);
+  sexp_release (data_bad);
+  sexp_release (data);
   return errtxt;
 }
 
   return errtxt;
 }
 
@@ -1233,22 +1230,21 @@ selftests_dsa (selftest_report_func_t report)
 
   /* Convert the S-expressions into the internal representation.  */
   what = "convert";
 
   /* Convert the S-expressions into the internal representation.  */
   what = "convert";
-  err = gcry_sexp_sscan (&skey, NULL,
-                         sample_secret_key, strlen (sample_secret_key));
+  err = sexp_sscan (&skey, NULL, sample_secret_key, strlen (sample_secret_key));
   if (!err)
   if (!err)
-    err = gcry_sexp_sscan (&pkey, NULL,
-                           sample_public_key, strlen (sample_public_key));
+    err = sexp_sscan (&pkey, NULL,
+                      sample_public_key, strlen (sample_public_key));
   if (err)
     {
   if (err)
     {
-      errtxt = gcry_strerror (err);
+      errtxt = _gcry_strerror (err);
       goto failed;
     }
 
   what = "key consistency";
       goto failed;
     }
 
   what = "key consistency";
-  err = gcry_pk_testkey (skey);
+  err = _gcry_pk_testkey (skey);
   if (err)
     {
   if (err)
     {
-      errtxt = gcry_strerror (err);
+      errtxt = _gcry_strerror (err);
       goto failed;
     }
 
       goto failed;
     }
 
@@ -1257,13 +1253,13 @@ selftests_dsa (selftest_report_func_t report)
   if (errtxt)
     goto failed;
 
   if (errtxt)
     goto failed;
 
-  gcry_sexp_release (pkey);
-  gcry_sexp_release (skey);
+  sexp_release (pkey);
+  sexp_release (skey);
   return 0; /* Succeeded. */
 
  failed:
   return 0; /* Succeeded. */
 
  failed:
-  gcry_sexp_release (pkey);
-  gcry_sexp_release (skey);
+  sexp_release (pkey);
+  sexp_release (skey);
   if (report)
     report ("pubkey", GCRY_PK_DSA, what, errtxt);
   return GPG_ERR_SELFTEST_FAILED;
   if (report)
     report ("pubkey", GCRY_PK_DSA, what, errtxt);
   return GPG_ERR_SELFTEST_FAILED;
index 74adaec..1ee1d39 100644 (file)
@@ -89,7 +89,7 @@ elliptic_curve_t _gcry_ecc_curve_copy (elliptic_curve_t E);
 const char *_gcry_ecc_model2str (enum gcry_mpi_ec_models model);
 const char *_gcry_ecc_dialect2str (enum ecc_dialects dialect);
 gcry_mpi_t   _gcry_ecc_ec2os (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t p);
 const char *_gcry_ecc_model2str (enum gcry_mpi_ec_models model);
 const char *_gcry_ecc_dialect2str (enum ecc_dialects dialect);
 gcry_mpi_t   _gcry_ecc_ec2os (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t p);
-gcry_error_t _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value);
+gcry_err_code_t _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value);
 
 mpi_point_t  _gcry_ecc_compute_public (mpi_point_t Q, mpi_ec_t ec,
                                        mpi_point_t G, gcry_mpi_t d);
 
 mpi_point_t  _gcry_ecc_compute_public (mpi_point_t Q, mpi_ec_t ec,
                                        mpi_point_t G, gcry_mpi_t d);
index f7c1c6d..5c418d9 100644 (file)
@@ -310,7 +310,7 @@ point_copy (gcry_mpi_point_t point)
 
   if (point)
     {
 
   if (point)
     {
-      newpoint = gcry_mpi_point_new (0);
+      newpoint = mpi_point_new (0);
       point_set (newpoint, point);
     }
   else
       point_set (newpoint, point);
     }
   else
@@ -323,12 +323,12 @@ point_copy (gcry_mpi_point_t point)
 static gcry_mpi_t
 scanval (const char *string)
 {
 static gcry_mpi_t
 scanval (const char *string)
 {
-  gpg_error_t err;
+  gpg_err_code_t rc;
   gcry_mpi_t val;
 
   gcry_mpi_t val;
 
-  err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
-  if (err)
-    log_fatal ("scanning ECC parameter failed: %s\n", gpg_strerror (err));
+  rc = _gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
+  if (rc)
+    log_fatal ("scanning ECC parameter failed: %s\n", gpg_strerror (rc));
   return val;
 }
 
   return val;
 }
 
@@ -524,9 +524,9 @@ _gcry_ecc_get_curve (gcry_sexp_t keyparms, int iterator, unsigned int *r_nbits)
   /*
    * Extract the curve parameters..
    */
   /*
    * Extract the curve parameters..
    */
-  rc = gpg_err_code (_gcry_sexp_extract_param (keyparms, NULL, "-pabgn",
-                                               &E.p, &E.a, &E.b, &mpi_g, &E.n,
-                                               NULL));
+  rc = gpg_err_code (sexp_extract_param (keyparms, NULL, "-pabgn",
+                                         &E.p, &E.a, &E.b, &mpi_g, &E.n,
+                                         NULL));
   if (rc == GPG_ERR_NO_OBJ)
     {
       /* This might be the second use case of checking whether a
   if (rc == GPG_ERR_NO_OBJ)
     {
       /* This might be the second use case of checking whether a
@@ -534,12 +534,12 @@ _gcry_ecc_get_curve (gcry_sexp_t keyparms, int iterator, unsigned int *r_nbits)
       gcry_sexp_t l1;
       char *name;
 
       gcry_sexp_t l1;
       char *name;
 
-      l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+      l1 = sexp_find_token (keyparms, "curve", 5);
       if (!l1)
         goto leave;  /* No curve name parameter.  */
 
       if (!l1)
         goto leave;  /* No curve name parameter.  */
 
-      name = _gcry_sexp_nth_string (l1, 1);
-      gcry_sexp_release (l1);
+      name = sexp_nth_string (l1, 1);
+      sexp_release (l1);
       if (!name)
         goto leave;  /* Name missing or out of core. */
 
       if (!name)
         goto leave;  /* Name missing or out of core. */
 
@@ -602,13 +602,13 @@ _gcry_ecc_get_curve (gcry_sexp_t keyparms, int iterator, unsigned int *r_nbits)
     }
 
  leave:
     }
 
  leave:
-  gcry_mpi_release (tmp);
-  gcry_mpi_release (E.p);
-  gcry_mpi_release (E.a);
-  gcry_mpi_release (E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (tmp);
+  _gcry_mpi_release (E.p);
+  _gcry_mpi_release (E.a);
+  _gcry_mpi_release (E.b);
+  _gcry_mpi_release (mpi_g);
   _gcry_mpi_point_free_parts (&E.G);
   _gcry_mpi_point_free_parts (&E.G);
-  gcry_mpi_release (E.n);
+  _gcry_mpi_release (E.n);
   return result;
 }
 
   return result;
 }
 
@@ -620,11 +620,11 @@ mpi_from_keyparam (gcry_mpi_t *r_a, gcry_sexp_t keyparam, const char *name)
   gcry_err_code_t ec = 0;
   gcry_sexp_t l1;
 
   gcry_err_code_t ec = 0;
   gcry_sexp_t l1;
 
-  l1 = gcry_sexp_find_token (keyparam, name, 0);
+  l1 = sexp_find_token (keyparam, name, 0);
   if (l1)
     {
   if (l1)
     {
-      *r_a = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-      gcry_sexp_release (l1);
+      *r_a = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+      sexp_release (l1);
       if (!*r_a)
         ec = GPG_ERR_INV_OBJ;
     }
       if (!*r_a)
         ec = GPG_ERR_INV_OBJ;
     }
@@ -644,17 +644,17 @@ point_from_keyparam (gcry_mpi_point_t *r_a,
   gcry_sexp_t l1;
   gcry_mpi_point_t point;
 
   gcry_sexp_t l1;
   gcry_mpi_point_t point;
 
-  l1 = gcry_sexp_find_token (keyparam, name, 0);
+  l1 = sexp_find_token (keyparam, name, 0);
   if (l1)
     {
       gcry_mpi_t a;
 
   if (l1)
     {
       gcry_mpi_t a;
 
-      a = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_OPAQUE);
-      gcry_sexp_release (l1);
+      a = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_OPAQUE);
+      sexp_release (l1);
       if (!a)
         return GPG_ERR_INV_OBJ;
 
       if (!a)
         return GPG_ERR_INV_OBJ;
 
-      point = gcry_mpi_point_new (0);
+      point = mpi_point_new (0);
       if (ec && ec->dialect == ECC_DIALECT_ED25519)
         rc = _gcry_ecc_eddsa_decodepoint (a, ec, point, NULL, NULL);
       else
       if (ec && ec->dialect == ECC_DIALECT_ED25519)
         rc = _gcry_ecc_eddsa_decodepoint (a, ec, point, NULL, NULL);
       else
@@ -662,7 +662,7 @@ point_from_keyparam (gcry_mpi_point_t *r_a,
       mpi_free (a);
       if (rc)
         {
       mpi_free (a);
       if (rc)
         {
-          gcry_mpi_point_release (point);
+          mpi_point_release (point);
           return rc;
         }
     }
           return rc;
         }
     }
@@ -703,7 +703,7 @@ point_from_keyparam (gcry_mpi_point_t *r_a,
       if (!z)
         z = mpi_set_ui (NULL, 1);
       if (x && y)
       if (!z)
         z = mpi_set_ui (NULL, 1);
       if (x && y)
-        point = gcry_mpi_point_snatch_set (NULL, x, y, z);
+        point = mpi_point_snatch_set (NULL, x, y, z);
       else
         {
           mpi_free (x);
       else
         {
           mpi_free (x);
@@ -750,18 +750,18 @@ _gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
   if (keyparam)
     {
       /* Parse an optional flags list.  */
   if (keyparam)
     {
       /* Parse an optional flags list.  */
-      l1 = gcry_sexp_find_token (keyparam, "flags", 0);
+      l1 = sexp_find_token (keyparam, "flags", 0);
       if (l1)
         {
           errc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
       if (l1)
         {
           errc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
-          gcry_sexp_release (l1);
+          sexp_release (l1);
           l1 = NULL;
           if (errc)
             goto leave;
         }
 
       /* Check whether a curve name was given.  */
           l1 = NULL;
           if (errc)
             goto leave;
         }
 
       /* Check whether a curve name was given.  */
-      l1 = gcry_sexp_find_token (keyparam, "curve", 5);
+      l1 = sexp_find_token (keyparam, "curve", 5);
 
       /* If we don't have a curve name or if override parameters have
          explicitly been requested, parse them.  */
 
       /* If we don't have a curve name or if override parameters have
          explicitly been requested, parse them.  */
@@ -798,8 +798,8 @@ _gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
 
       if (l1)
         {
 
       if (l1)
         {
-          name = _gcry_sexp_nth_string (l1, 1);
-          gcry_sexp_release (l1);
+          name = sexp_nth_string (l1, 1);
+          sexp_release (l1);
           if (!name)
             {
               errc = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
           if (!name)
             {
               errc = GPG_ERR_INV_OBJ; /* Name missing or out of core. */
@@ -845,7 +845,7 @@ _gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
         }
       if (!G)
         {
         }
       if (!G)
         {
-          G = gcry_mpi_point_snatch_set (NULL, E->G.x, E->G.y, E->G.z);
+          G = mpi_point_snatch_set (NULL, E->G.x, E->G.y, E->G.z);
           E->G.x = NULL;
           E->G.y = NULL;
           E->G.z = NULL;
           E->G.x = NULL;
           E->G.y = NULL;
           E->G.z = NULL;
@@ -913,13 +913,13 @@ _gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
     }
 
  leave:
     }
 
  leave:
-  gcry_ctx_release (ctx);
+  _gcry_ctx_release (ctx);
   mpi_free (p);
   mpi_free (a);
   mpi_free (b);
   mpi_free (p);
   mpi_free (a);
   mpi_free (b);
-  gcry_mpi_point_release (G);
+  _gcry_mpi_point_release (G);
   mpi_free (n);
   mpi_free (n);
-  gcry_mpi_point_release (Q);
+  _gcry_mpi_point_release (Q);
   mpi_free (d);
   return errc;
 }
   mpi_free (d);
   return errc;
 }
@@ -976,13 +976,13 @@ _gcry_ecc_get_param_sexp (const char *name)
   if (_gcry_ecc_get_param (name, pkey))
     return NULL;
 
   if (_gcry_ecc_get_param (name, pkey))
     return NULL;
 
-  if (gcry_sexp_build (&result, NULL,
-                       "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)))",
-                       pkey[0], pkey[1], pkey[2], pkey[3], pkey[4]))
+  if (sexp_build (&result, NULL,
+                  "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)))",
+                  pkey[0], pkey[1], pkey[2], pkey[3], pkey[4]))
     result = NULL;
 
   for (i=0; pkey[i]; i++)
     result = NULL;
 
   for (i=0; pkey[i]; i++)
-    gcry_mpi_release (pkey[i]);
+    _gcry_mpi_release (pkey[i]);
 
   return result;
 }
 
   return result;
 }
@@ -1045,7 +1045,7 @@ _gcry_ecc_get_mpi (const char *name, mpi_ec_t ec, int copy)
 
           if (!_gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
                                             &encpk, &encpklen))
 
           if (!_gcry_ecc_eddsa_encodepoint (ec->Q, ec, NULL, NULL,
                                             &encpk, &encpklen))
-            return gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
+            return mpi_set_opaque (NULL, encpk, encpklen*8);
         }
     }
 
         }
     }
 
@@ -1108,7 +1108,7 @@ _gcry_ecc_set_mpi (const char *name, gcry_mpi_t newvalue, mpi_ec_t ec)
       if (newvalue)
         {
           if (!ec->Q)
       if (newvalue)
         {
           if (!ec->Q)
-            ec->Q = gcry_mpi_point_new (0);
+            ec->Q = mpi_point_new (0);
           if (ec->dialect == ECC_DIALECT_ED25519)
             rc = _gcry_ecc_eddsa_decodepoint (newvalue, ec, ec->Q, NULL, NULL);
           else
           if (ec->dialect == ECC_DIALECT_ED25519)
             rc = _gcry_ecc_eddsa_decodepoint (newvalue, ec, ec->Q, NULL, NULL);
           else
@@ -1116,7 +1116,7 @@ _gcry_ecc_set_mpi (const char *name, gcry_mpi_t newvalue, mpi_ec_t ec)
         }
       if (rc || !newvalue)
         {
         }
       if (rc || !newvalue)
         {
-          gcry_mpi_point_release (ec->Q);
+          _gcry_mpi_point_release (ec->Q);
           ec->Q = NULL;
         }
       /* Note: We assume that Q matches d and thus do not reset d.  */
           ec->Q = NULL;
         }
       /* Note: We assume that Q matches d and thus do not reset d.  */
@@ -1129,7 +1129,7 @@ _gcry_ecc_set_mpi (const char *name, gcry_mpi_t newvalue, mpi_ec_t ec)
         {
           /* We need to reset the public key because it may not
              anymore match.  */
         {
           /* We need to reset the public key because it may not
              anymore match.  */
-          gcry_mpi_point_release (ec->Q);
+          _gcry_mpi_point_release (ec->Q);
           ec->Q = NULL;
         }
     }
           ec->Q = NULL;
         }
     }
@@ -1146,12 +1146,12 @@ _gcry_ecc_set_point (const char *name, gcry_mpi_point_t newvalue, mpi_ec_t ec)
 {
   if (!strcmp (name, "g"))
     {
 {
   if (!strcmp (name, "g"))
     {
-      gcry_mpi_point_release (ec->G);
+      _gcry_mpi_point_release (ec->G);
       ec->G = point_copy (newvalue);
     }
   else if (!strcmp (name, "q"))
     {
       ec->G = point_copy (newvalue);
     }
   else if (!strcmp (name, "q"))
     {
-      gcry_mpi_point_release (ec->Q);
+      _gcry_mpi_point_release (ec->Q);
       ec->Q = point_copy (newvalue);
     }
   else
       ec->Q = point_copy (newvalue);
     }
   else
index 7663623..b4bbe2c 100644 (file)
@@ -42,7 +42,7 @@ _gcry_ecc_ecdsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
                       gcry_mpi_t r, gcry_mpi_t s,
                       int flags, int hashalgo)
 {
                       gcry_mpi_t r, gcry_mpi_t s,
                       int flags, int hashalgo)
 {
-  gpg_err_code_t err = 0;
+  gpg_err_code_t rc = 0;
   int extraloops = 0;
   gcry_mpi_t k, dr, sum, k_1, x;
   mpi_point_struct I;
   int extraloops = 0;
   gcry_mpi_t k, dr, sum, k_1, x;
   mpi_point_struct I;
@@ -59,13 +59,12 @@ _gcry_ecc_ecdsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
   /* Convert the INPUT into an MPI if needed.  */
   if (mpi_is_opaque (input))
     {
   /* Convert the INPUT into an MPI if needed.  */
   if (mpi_is_opaque (input))
     {
-      abuf = gcry_mpi_get_opaque (input, &abits);
-      err = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
-                                         abuf, (abits+7)/8, NULL));
-      if (err)
-        return err;
+      abuf = mpi_get_opaque (input, &abits);
+      rc = _gcry_mpi_scan (&hash, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
+      if (rc)
+        return rc;
       if (abits > qbits)
       if (abits > qbits)
-        gcry_mpi_rshift (hash, hash, abits - qbits);
+        mpi_rshift (hash, hash, abits - qbits);
     }
   else
     hash = input;
     }
   else
     hash = input;
@@ -98,15 +97,15 @@ _gcry_ecc_ecdsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
                  used as h1 from 3.2.a.  */
               if (!mpi_is_opaque (input))
                 {
                  used as h1 from 3.2.a.  */
               if (!mpi_is_opaque (input))
                 {
-                  err = GPG_ERR_CONFLICT;
+                  rc = GPG_ERR_CONFLICT;
                   goto leave;
                 }
 
                   goto leave;
                 }
 
-              abuf = gcry_mpi_get_opaque (input, &abits);
-              err = _gcry_dsa_gen_rfc6979_k (&k, skey->E.n, skey->d,
-                                             abuf, (abits+7)/8,
-                                             hashalgo, extraloops);
-              if (err)
+              abuf = mpi_get_opaque (input, &abits);
+              rc = _gcry_dsa_gen_rfc6979_k (&k, skey->E.n, skey->d,
+                                            abuf, (abits+7)/8,
+                                            hashalgo, extraloops);
+              if (rc)
                 goto leave;
               extraloops++;
             }
                 goto leave;
               extraloops++;
             }
@@ -118,7 +117,7 @@ _gcry_ecc_ecdsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
             {
               if (DBG_CIPHER)
                 log_debug ("ecc sign: Failed to get affine coordinates\n");
             {
               if (DBG_CIPHER)
                 log_debug ("ecc sign: Failed to get affine coordinates\n");
-              err = GPG_ERR_BAD_SIGNATURE;
+              rc = GPG_ERR_BAD_SIGNATURE;
               goto leave;
             }
           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
               goto leave;
             }
           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
@@ -150,7 +149,7 @@ _gcry_ecc_ecdsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
   if (hash != input)
     mpi_free (hash);
 
   if (hash != input)
     mpi_free (hash);
 
-  return err;
+  return rc;
 }
 
 
 }
 
 
index 29145f8..12cdea0 100644 (file)
@@ -50,12 +50,12 @@ reverse_buffer (unsigned char *buffer, unsigned int length)
 static gcry_mpi_t
 scanval (const char *string)
 {
 static gcry_mpi_t
 scanval (const char *string)
 {
-  gpg_error_t err;
+  gpg_err_code_t rc;
   gcry_mpi_t val;
 
   gcry_mpi_t val;
 
-  err = gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
-  if (err)
-    log_fatal ("scanning ECC parameter failed: %s\n", gpg_strerror (err));
+  rc = _gcry_mpi_scan (&val, GCRYMPI_FMT_HEX, string, 0, NULL);
+  if (rc)
+    log_fatal ("scanning ECC parameter failed: %s\n", gpg_strerror (rc));
   return val;
 }
 
   return val;
 }
 
@@ -150,7 +150,7 @@ _gcry_ecc_eddsa_ensure_compact (gcry_mpi_t value, unsigned int nbits)
 
   if (!mpi_is_opaque (value))
     return GPG_ERR_INV_OBJ;
 
   if (!mpi_is_opaque (value))
     return GPG_ERR_INV_OBJ;
-  buf = gcry_mpi_get_opaque (value, &rawmpilen);
+  buf = mpi_get_opaque (value, &rawmpilen);
   if (!buf)
     return GPG_ERR_INV_OBJ;
   rawmpilen = (rawmpilen + 7)/8;
   if (!buf)
     return GPG_ERR_INV_OBJ;
   rawmpilen = (rawmpilen + 7)/8;
@@ -159,12 +159,12 @@ _gcry_ecc_eddsa_ensure_compact (gcry_mpi_t value, unsigned int nbits)
      uncompressed format.  In this case extract y and compress.  */
   if (rawmpilen > 1 && buf[0] == 0x04 && (rawmpilen%2))
     {
      uncompressed format.  In this case extract y and compress.  */
   if (rawmpilen > 1 && buf[0] == 0x04 && (rawmpilen%2))
     {
-      rc = gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
-                          buf+1, (rawmpilen-1)/2, NULL);
+      rc = _gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
+                           buf+1, (rawmpilen-1)/2, NULL);
       if (rc)
         return rc;
       if (rc)
         return rc;
-      rc = gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
-                          buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
+      rc = _gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
+                           buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
       if (rc)
         {
           mpi_free (x);
       if (rc)
         {
           mpi_free (x);
@@ -177,7 +177,7 @@ _gcry_ecc_eddsa_ensure_compact (gcry_mpi_t value, unsigned int nbits)
       if (rc)
         return rc;
 
       if (rc)
         return rc;
 
-      gcry_mpi_set_opaque (value, enc, 8*enclen);
+      mpi_set_opaque (value, enc, 8*enclen);
     }
 
   return 0;
     }
 
   return 0;
@@ -233,7 +233,7 @@ _gcry_ecc_eddsa_recover_x (gcry_mpi_t x, gcry_mpi_t y, int sign, mpi_ec_t ec)
   mpi_mulm (t, x, x, ec->p);
   mpi_mulm (t, t, v, ec->p);
   /* -t == u ? x = x * sqrt(-1) */
   mpi_mulm (t, x, x, ec->p);
   mpi_mulm (t, t, v, ec->p);
   /* -t == u ? x = x * sqrt(-1) */
-  gcry_mpi_neg (t, t);
+  mpi_neg (t, t);
   if (!mpi_cmp (t, u))
     {
       static gcry_mpi_t m1;  /* Fixme: this is not thread-safe.  */
   if (!mpi_cmp (t, u))
     {
       static gcry_mpi_t m1;  /* Fixme: this is not thread-safe.  */
@@ -245,7 +245,7 @@ _gcry_ecc_eddsa_recover_x (gcry_mpi_t x, gcry_mpi_t y, int sign, mpi_ec_t ec)
       mpi_mulm (t, x, x, ec->p);
       mpi_mulm (t, t, v, ec->p);
       /* -t == u ? x = x * sqrt(-1) */
       mpi_mulm (t, x, x, ec->p);
       mpi_mulm (t, t, v, ec->p);
       /* -t == u ? x = x * sqrt(-1) */
-      gcry_mpi_neg (t, t);
+      mpi_neg (t, t);
       if (!mpi_cmp (t, u))
         rc = GPG_ERR_INV_OBJ;
     }
       if (!mpi_cmp (t, u))
         rc = GPG_ERR_INV_OBJ;
     }
@@ -282,7 +282,7 @@ _gcry_ecc_eddsa_decodepoint (gcry_mpi_t pk, mpi_ec_t ctx, mpi_point_t result,
     {
       const unsigned char *buf;
 
     {
       const unsigned char *buf;
 
-      buf = gcry_mpi_get_opaque (pk, &rawmpilen);
+      buf = mpi_get_opaque (pk, &rawmpilen);
       if (!buf)
         return GPG_ERR_INV_OBJ;
       rawmpilen = (rawmpilen + 7)/8;
       if (!buf)
         return GPG_ERR_INV_OBJ;
       rawmpilen = (rawmpilen + 7)/8;
@@ -295,12 +295,12 @@ _gcry_ecc_eddsa_decodepoint (gcry_mpi_t pk, mpi_ec_t ctx, mpi_point_t result,
         {
           gcry_mpi_t x, y;
 
         {
           gcry_mpi_t x, y;
 
-          rc = gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
-                              buf+1, (rawmpilen-1)/2, NULL);
+          rc = _gcry_mpi_scan (&x, GCRYMPI_FMT_STD,
+                               buf+1, (rawmpilen-1)/2, NULL);
           if (rc)
             return rc;
           if (rc)
             return rc;
-          rc = gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
-                              buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
+          rc = _gcry_mpi_scan (&y, GCRYMPI_FMT_STD,
+                               buf+1+(rawmpilen-1)/2, (rawmpilen-1)/2, NULL);
           if (rc)
             {
               mpi_free (x);
           if (rc)
             {
               mpi_free (x);
@@ -397,7 +397,7 @@ _gcry_ecc_eddsa_genkey (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
       goto leave;
     }
   dlen = b;
       goto leave;
     }
   dlen = b;
-  dbuf = gcry_random_bytes_secure (dlen, random_level);
+  dbuf = _gcry_random_bytes_secure (dlen, random_level);
 
   /* Compute the A value.  */
   hvec[0].data = dbuf;
 
   /* Compute the A value.  */
   hvec[0].data = dbuf;
@@ -433,9 +433,9 @@ _gcry_ecc_eddsa_genkey (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
 
  leave:
   point_free (&Q);
 
  leave:
   point_free (&Q);
-  gcry_mpi_release (a);
-  gcry_mpi_release (x);
-  gcry_mpi_release (y);
+  _gcry_mpi_release (a);
+  _gcry_mpi_release (x);
+  _gcry_mpi_release (y);
   gcry_free (hash_d);
   return rc;
 }
   gcry_free (hash_d);
   return rc;
 }
@@ -554,7 +554,7 @@ _gcry_ecc_eddsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
     }
 
   /* Compute R.  */
     }
 
   /* Compute R.  */
-  mbuf = gcry_mpi_get_opaque (input, &tmp);
+  mbuf = mpi_get_opaque (input, &tmp);
   mlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     m", mbuf, mlen);
   mlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     m", mbuf, mlen);
@@ -597,7 +597,7 @@ _gcry_ecc_eddsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
     goto leave;
 
   /* No more need for RAWMPI thus we now transfer it to R_R.  */
     goto leave;
 
   /* No more need for RAWMPI thus we now transfer it to R_R.  */
-  gcry_mpi_set_opaque (r_r, rawmpi, rawmpilen*8);
+  mpi_set_opaque (r_r, rawmpi, rawmpilen*8);
   rawmpi = NULL;
 
   reverse_buffer (digest, 64);
   rawmpi = NULL;
 
   reverse_buffer (digest, 64);
@@ -611,16 +611,16 @@ _gcry_ecc_eddsa_sign (gcry_mpi_t input, ECC_secret_key *skey,
     goto leave;
   if (DBG_CIPHER)
     log_printhex ("   e_s", rawmpi, rawmpilen);
     goto leave;
   if (DBG_CIPHER)
     log_printhex ("   e_s", rawmpi, rawmpilen);
-  gcry_mpi_set_opaque (s, rawmpi, rawmpilen*8);
+  mpi_set_opaque (s, rawmpi, rawmpilen*8);
   rawmpi = NULL;
 
   rc = 0;
 
  leave:
   rawmpi = NULL;
 
   rc = 0;
 
  leave:
-  gcry_mpi_release (a);
-  gcry_mpi_release (x);
-  gcry_mpi_release (y);
-  gcry_mpi_release (r);
+  _gcry_mpi_release (a);
+  _gcry_mpi_release (x);
+  _gcry_mpi_release (y);
+  _gcry_mpi_release (r);
   gcry_free (digest);
   _gcry_mpi_ec_free (ctx);
   point_free (&I);
   gcry_free (digest);
   _gcry_mpi_ec_free (ctx);
   point_free (&I);
@@ -691,11 +691,11 @@ _gcry_ecc_eddsa_verify (gcry_mpi_t input, ECC_public_key *pkey,
     }
 
   /* Convert the other input parameters.  */
     }
 
   /* Convert the other input parameters.  */
-  mbuf = gcry_mpi_get_opaque (input, &tmp);
+  mbuf = mpi_get_opaque (input, &tmp);
   mlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     m", mbuf, mlen);
   mlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     m", mbuf, mlen);
-  rbuf = gcry_mpi_get_opaque (r_in, &tmp);
+  rbuf = mpi_get_opaque (r_in, &tmp);
   rlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     r", rbuf, rlen);
   rlen = (tmp +7)/8;
   if (DBG_CIPHER)
     log_printhex ("     r", rbuf, rlen);
@@ -763,8 +763,8 @@ _gcry_ecc_eddsa_verify (gcry_mpi_t input, ECC_public_key *pkey,
   gcry_free (encpk);
   gcry_free (tbuf);
   _gcry_mpi_ec_free (ctx);
   gcry_free (encpk);
   gcry_free (tbuf);
   _gcry_mpi_ec_free (ctx);
-  gcry_mpi_release (s);
-  gcry_mpi_release (h);
+  _gcry_mpi_release (s);
+  _gcry_mpi_release (h);
   point_free (&Ia);
   point_free (&Ib);
   point_free (&Q);
   point_free (&Ia);
   point_free (&Ib);
   point_free (&Q);
index ce3e921..a34fa08 100644 (file)
@@ -41,7 +41,7 @@ gpg_err_code_t
 _gcry_ecc_gost_sign (gcry_mpi_t input, ECC_secret_key *skey,
                      gcry_mpi_t r, gcry_mpi_t s)
 {
 _gcry_ecc_gost_sign (gcry_mpi_t input, ECC_secret_key *skey,
                      gcry_mpi_t r, gcry_mpi_t s)
 {
-  gpg_err_code_t err = 0;
+  gpg_err_code_t rc = 0;
   gcry_mpi_t k, dr, sum, ke, x, e;
   mpi_point_struct I;
   gcry_mpi_t hash;
   gcry_mpi_t k, dr, sum, ke, x, e;
   mpi_point_struct I;
   gcry_mpi_t hash;
@@ -57,13 +57,12 @@ _gcry_ecc_gost_sign (gcry_mpi_t input, ECC_secret_key *skey,
   /* Convert the INPUT into an MPI if needed.  */
   if (mpi_is_opaque (input))
     {
   /* Convert the INPUT into an MPI if needed.  */
   if (mpi_is_opaque (input))
     {
-      abuf = gcry_mpi_get_opaque (input, &abits);
-      err = gpg_err_code (gcry_mpi_scan (&hash, GCRYMPI_FMT_USG,
-                                         abuf, (abits+7)/8, NULL));
-      if (err)
-        return err;
+      abuf = mpi_get_opaque (input, &abits);
+      rc = _gcry_mpi_scan (&hash, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
+      if (rc)
+        return rc;
       if (abits > qbits)
       if (abits > qbits)
-        gcry_mpi_rshift (hash, hash, abits - qbits);
+        mpi_rshift (hash, hash, abits - qbits);
     }
   else
     hash = input;
     }
   else
     hash = input;
@@ -100,7 +99,7 @@ _gcry_ecc_gost_sign (gcry_mpi_t input, ECC_secret_key *skey,
             {
               if (DBG_CIPHER)
                 log_debug ("ecc sign: Failed to get affine coordinates\n");
             {
               if (DBG_CIPHER)
                 log_debug ("ecc sign: Failed to get affine coordinates\n");
-              err = GPG_ERR_BAD_SIGNATURE;
+              rc = GPG_ERR_BAD_SIGNATURE;
               goto leave;
             }
           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
               goto leave;
             }
           mpi_mod (r, x, skey->E.n);  /* r = x mod n */
@@ -131,7 +130,7 @@ _gcry_ecc_gost_sign (gcry_mpi_t input, ECC_secret_key *skey,
   if (hash != input)
     mpi_free (hash);
 
   if (hash != input)
     mpi_free (hash);
 
-  return err;
+  return rc;
 }
 
 
 }
 
 
index 1633d32..26c9e8d 100644 (file)
@@ -104,7 +104,7 @@ _gcry_ecc_dialect2str (enum ecc_dialects dialect)
 gcry_mpi_t
 _gcry_ecc_ec2os (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t p)
 {
 gcry_mpi_t
 _gcry_ecc_ec2os (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t p)
 {
-  gpg_error_t err;
+  gpg_err_code_t rc;
   int pbytes = (mpi_get_nbits (p)+7)/8;
   size_t n;
   unsigned char *buf, *ptr;
   int pbytes = (mpi_get_nbits (p)+7)/8;
   size_t n;
   unsigned char *buf, *ptr;
@@ -113,27 +113,27 @@ _gcry_ecc_ec2os (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t p)
   buf = gcry_xmalloc ( 1 + 2*pbytes );
   *buf = 04; /* Uncompressed point.  */
   ptr = buf+1;
   buf = gcry_xmalloc ( 1 + 2*pbytes );
   *buf = 04; /* Uncompressed point.  */
   ptr = buf+1;
-  err = gcry_mpi_print (GCRYMPI_FMT_USG, ptr, pbytes, &n, x);
-  if (err)
-    log_fatal ("mpi_print failed: %s\n", gpg_strerror (err));
+  rc = _gcry_mpi_print (GCRYMPI_FMT_USG, ptr, pbytes, &n, x);
+  if (rc)
+    log_fatal ("mpi_print failed: %s\n", gpg_strerror (rc));
   if (n < pbytes)
     {
       memmove (ptr+(pbytes-n), ptr, n);
       memset (ptr, 0, (pbytes-n));
     }
   ptr += pbytes;
   if (n < pbytes)
     {
       memmove (ptr+(pbytes-n), ptr, n);
       memset (ptr, 0, (pbytes-n));
     }
   ptr += pbytes;
-  err = gcry_mpi_print (GCRYMPI_FMT_USG, ptr, pbytes, &n, y);
-  if (err)
-    log_fatal ("mpi_print failed: %s\n", gpg_strerror (err));
+  rc = _gcry_mpi_print (GCRYMPI_FMT_USG, ptr, pbytes, &n, y);
+  if (rc)
+    log_fatal ("mpi_print failed: %s\n", gpg_strerror (rc));
   if (n < pbytes)
     {
       memmove (ptr+(pbytes-n), ptr, n);
       memset (ptr, 0, (pbytes-n));
     }
 
   if (n < pbytes)
     {
       memmove (ptr+(pbytes-n), ptr, n);
       memset (ptr, 0, (pbytes-n));
     }
 
-  err = gcry_mpi_scan (&result, GCRYMPI_FMT_USG, buf, 1+2*pbytes, NULL);
-  if (err)
-    log_fatal ("mpi_scan failed: %s\n", gpg_strerror (err));
+  rc = _gcry_mpi_scan (&result, GCRYMPI_FMT_USG, buf, 1+2*pbytes, NULL);
+  if (rc)
+    log_fatal ("mpi_scan failed: %s\n", gpg_strerror (rc));
   gcry_free (buf);
 
   return result;
   gcry_free (buf);
 
   return result;
@@ -163,10 +163,10 @@ _gcry_mpi_ec_ec2os (gcry_mpi_point_t point, mpi_ec_t ectx)
 
 /* RESULT must have been initialized and is set on success to the
    point given by VALUE.  */
 
 /* RESULT must have been initialized and is set on success to the
    point given by VALUE.  */
-gcry_error_t
+gcry_err_code_t
 _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value)
 {
 _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value)
 {
-  gcry_error_t err;
+  gcry_err_code_t rc;
   size_t n;
   const unsigned char *buf;
   unsigned char *buf_memory;
   size_t n;
   const unsigned char *buf;
   unsigned char *buf_memory;
@@ -176,7 +176,7 @@ _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value)
     {
       unsigned int nbits;
 
     {
       unsigned int nbits;
 
-      buf = gcry_mpi_get_opaque (value, &nbits);
+      buf = mpi_get_opaque (value, &nbits);
       if (!buf)
         return GPG_ERR_INV_OBJ;
       n = (nbits + 7)/8;
       if (!buf)
         return GPG_ERR_INV_OBJ;
       n = (nbits + 7)/8;
@@ -186,11 +186,11 @@ _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value)
     {
       n = (mpi_get_nbits (value)+7)/8;
       buf_memory= gcry_xmalloc (n);
     {
       n = (mpi_get_nbits (value)+7)/8;
       buf_memory= gcry_xmalloc (n);
-      err = gcry_mpi_print (GCRYMPI_FMT_USG, buf_memory, n, &n, value);
-      if (err)
+      rc = _gcry_mpi_print (GCRYMPI_FMT_USG, buf_memory, n, &n, value);
+      if (rc)
         {
           gcry_free (buf_memory);
         {
           gcry_free (buf_memory);
-          return err;
+          return rc;
         }
       buf = buf_memory;
     }
         }
       buf = buf_memory;
     }
@@ -211,18 +211,18 @@ _gcry_ecc_os2ec (mpi_point_t result, gcry_mpi_t value)
       return GPG_ERR_INV_OBJ;
     }
   n = (n-1)/2;
       return GPG_ERR_INV_OBJ;
     }
   n = (n-1)/2;
-  err = gcry_mpi_scan (&x, GCRYMPI_FMT_USG, buf+1, n, NULL);
-  if (err)
+  rc = _gcry_mpi_scan (&x, GCRYMPI_FMT_USG, buf+1, n, NULL);
+  if (rc)
     {
       gcry_free (buf_memory);
     {
       gcry_free (buf_memory);
-      return err;
+      return rc;
     }
     }
-  err = gcry_mpi_scan (&y, GCRYMPI_FMT_USG, buf+1+n, n, NULL);
+  rc = _gcry_mpi_scan (&y, GCRYMPI_FMT_USG, buf+1+n, n, NULL);
   gcry_free (buf_memory);
   gcry_free (buf_memory);
-  if (err)
+  if (rc)
     {
       mpi_free (x);
     {
       mpi_free (x);
-      return err;
+      return rc;
     }
 
   mpi_set (result->x, x);
     }
 
   mpi_set (result->x, x);
@@ -316,7 +316,7 @@ _gcry_ecc_compute_public (mpi_point_t Q, mpi_ec_t ec,
 
       /* And finally the public key.  */
       if (!Q)
 
       /* And finally the public key.  */
       if (!Q)
-        Q = gcry_mpi_point_new (0);
+        Q = mpi_point_new (0);
       if (Q)
         _gcry_mpi_ec_mul_point (Q, a, G, ec);
       mpi_free (a);
       if (Q)
         _gcry_mpi_ec_mul_point (Q, a, G, ec);
       mpi_free (a);
@@ -324,7 +324,7 @@ _gcry_ecc_compute_public (mpi_point_t Q, mpi_ec_t ec,
   else
     {
       if (!Q)
   else
     {
       if (!Q)
-        Q = gcry_mpi_point_new (0);
+        Q = mpi_point_new (0);
       if (Q)
         _gcry_mpi_ec_mul_point (Q, d, G, ec);
     }
       if (Q)
         _gcry_mpi_ec_mul_point (Q, d, G, ec);
     }
index bda2a86..a7de254 100644 (file)
@@ -122,7 +122,7 @@ nist_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
       char *rndbuf;
 
       sk->d = mpi_snew (256);
       char *rndbuf;
 
       sk->d = mpi_snew (256);
-      rndbuf = gcry_random_bytes_secure (32, random_level);
+      rndbuf = _gcry_random_bytes_secure (32, random_level);
       rndbuf[0] &= 0x7f;  /* Clear bit 255. */
       rndbuf[0] |= 0x40;  /* Set bit 254.   */
       rndbuf[31] &= 0xf8; /* Clear bits 2..0 so that d mod 8 == 0  */
       rndbuf[0] &= 0x7f;  /* Clear bit 255. */
       rndbuf[0] |= 0x40;  /* Set bit 254.   */
       rndbuf[31] &= 0xf8; /* Clear bits 2..0 so that d mod 8 == 0  */
@@ -181,11 +181,10 @@ nist_generate_key (ECC_secret_key *sk, elliptic_curve_t *E, mpi_ec_t ctx,
              the smallest one */
           mpi_sub (sk->d, E->n, sk->d);   /* d = order - d */
           if (E->model == MPI_EC_WEIERSTRASS)
              the smallest one */
           mpi_sub (sk->d, E->n, sk->d);   /* d = order - d */
           if (E->model == MPI_EC_WEIERSTRASS)
-            gcry_mpi_point_snatch_set (&sk->Q, x, negative,
+            mpi_point_snatch_set (&sk->Q, x, negative,
                                        mpi_alloc_set_ui (1));
           else
                                        mpi_alloc_set_ui (1));
           else
-            gcry_mpi_point_snatch_set (&sk->Q, negative, y,
-                                       mpi_alloc_set_ui (1));
+            mpi_point_snatch_set (&sk->Q, negative, y, mpi_alloc_set_ui (1));
 
           if (DBG_CIPHER)
             log_debug ("ecgen converted Q to a compliant point\n");
 
           if (DBG_CIPHER)
             log_debug ("ecgen converted Q to a compliant point\n");
@@ -244,7 +243,7 @@ test_keys (ECC_secret_key *sk, unsigned int nbits)
   point_init (&pk.Q);
   point_set (&pk.Q, &sk->Q);
 
   point_init (&pk.Q);
   point_set (&pk.Q, &sk->Q);
 
-  gcry_mpi_randomize (test, nbits, GCRY_WEAK_RANDOM);
+  _gcry_mpi_randomize (test, nbits, GCRY_WEAK_RANDOM);
 
   if (_gcry_ecc_ecdsa_sign (test, sk, r, s, 0, 0) )
     log_fatal ("ECDSA operation: sign failed\n");
 
   if (_gcry_ecc_ecdsa_sign (test, sk, r, s, 0, 0) )
     log_fatal ("ECDSA operation: sign failed\n");
@@ -413,31 +412,31 @@ ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
     return rc;
 
   /* Parse the optional "curve" parameter. */
     return rc;
 
   /* Parse the optional "curve" parameter. */
-  l1 = gcry_sexp_find_token (genparms, "curve", 0);
+  l1 = sexp_find_token (genparms, "curve", 0);
   if (l1)
     {
       curve_name = _gcry_sexp_nth_string (l1, 1);
   if (l1)
     {
       curve_name = _gcry_sexp_nth_string (l1, 1);
-      gcry_sexp_release (l1);
+      sexp_release (l1);
       if (!curve_name)
         return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
     }
 
   /* Parse the optional flags list.  */
       if (!curve_name)
         return GPG_ERR_INV_OBJ; /* No curve name or value too large. */
     }
 
   /* Parse the optional flags list.  */
-  l1 = gcry_sexp_find_token (genparms, "flags", 0);
+  l1 = sexp_find_token (genparms, "flags", 0);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
-      gcry_sexp_release (l1);
+      sexp_release (l1);
       if (rc)
         goto leave;
     }
 
   /* Parse the deprecated optional transient-key flag.  */
       if (rc)
         goto leave;
     }
 
   /* Parse the deprecated optional transient-key flag.  */
-  l1 = gcry_sexp_find_token (genparms, "transient-key", 0);
+  l1 = sexp_find_token (genparms, "transient-key", 0);
   if (l1)
     {
       flags |= PUBKEY_FLAG_TRANSIENT_KEY;
   if (l1)
     {
       flags |= PUBKEY_FLAG_TRANSIENT_KEY;
-      gcry_sexp_release (l1);
+      sexp_release (l1);
     }
 
   /* NBITS is required if no curve name has been given.  */
     }
 
   /* NBITS is required if no curve name has been given.  */
@@ -492,7 +491,7 @@ ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
       if (rc)
         return rc;
       public = mpi_new (0);
       if (rc)
         return rc;
       public = mpi_new (0);
-      gcry_mpi_set_opaque (public, encpk, encpklen*8);
+      mpi_set_opaque (public, encpk, encpklen*8);
       encpk = NULL;
     }
   else
       encpk = NULL;
     }
   else
@@ -504,14 +503,14 @@ ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
   secret = sk.d; sk.d = NULL;
   if (E.name)
     {
   secret = sk.d; sk.d = NULL;
   if (E.name)
     {
-      rc = gcry_sexp_build (&curve_info, NULL, "(curve %s)", E.name);
+      rc = sexp_build (&curve_info, NULL, "(curve %s)", E.name);
       if (rc)
         goto leave;
     }
 
   if ((flags & PUBKEY_FLAG_PARAM) || (flags & PUBKEY_FLAG_EDDSA))
     {
       if (rc)
         goto leave;
     }
 
   if ((flags & PUBKEY_FLAG_PARAM) || (flags & PUBKEY_FLAG_EDDSA))
     {
-      rc = gcry_sexp_build
+      rc = sexp_build
         (&curve_flags, NULL,
          ((flags & PUBKEY_FLAG_PARAM) && (flags & PUBKEY_FLAG_EDDSA))?
          "(flags param eddsa)" :
         (&curve_flags, NULL,
          ((flags & PUBKEY_FLAG_PARAM) && (flags & PUBKEY_FLAG_EDDSA))?
          "(flags param eddsa)" :
@@ -523,29 +522,29 @@ ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
     }
 
   if ((flags & PUBKEY_FLAG_PARAM) && E.name)
     }
 
   if ((flags & PUBKEY_FLAG_PARAM) && E.name)
-    rc = gcry_sexp_build (r_skey, NULL,
-                          "(key-data"
-                          " (public-key"
-                          "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
-                          " (private-key"
-                          "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
-                          " )",
-                          curve_info, curve_flags,
-                          sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
-                          curve_info, curve_flags,
-                          sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
+    rc = sexp_build (r_skey, NULL,
+                     "(key-data"
+                     " (public-key"
+                     "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))"
+                     " (private-key"
+                     "  (ecc%S%S(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))"
+                     " )",
+                     curve_info, curve_flags,
+                     sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public,
+                     curve_info, curve_flags,
+                     sk.E.p, sk.E.a, sk.E.b, base, sk.E.n, public, secret);
   else
   else
-    rc = gcry_sexp_build (r_skey, NULL,
-                          "(key-data"
-                          " (public-key"
-                          "  (ecc%S%S(q%m)))"
-                          " (private-key"
-                          "  (ecc%S%S(q%m)(d%m)))"
-                          " )",
-                          curve_info, curve_flags,
-                          public,
-                          curve_info, curve_flags,
-                          public, secret);
+    rc = sexp_build (r_skey, NULL,
+                     "(key-data"
+                     " (public-key"
+                     "  (ecc%S%S(q%m)))"
+                     " (private-key"
+                     "  (ecc%S%S(q%m)(d%m)))"
+                     " )",
+                     curve_info, curve_flags,
+                     public,
+                     curve_info, curve_flags,
+                     public, secret);
   if (rc)
     goto leave;
 
   if (rc)
     goto leave;
 
@@ -575,8 +574,8 @@ ecc_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
   mpi_free (x);
   mpi_free (y);
   _gcry_mpi_ec_free (ctx);
   mpi_free (x);
   mpi_free (y);
   _gcry_mpi_ec_free (ctx);
-  gcry_sexp_release (curve_flags);
-  gcry_sexp_release (curve_info);
+  sexp_release (curve_flags);
+  sexp_release (curve_info);
   return rc;
 }
 
   return rc;
 }
 
@@ -596,7 +595,7 @@ ecc_check_secret_key (gcry_sexp_t keyparms)
   memset (&sk, 0, sizeof sk);
 
   /* Look for flags. */
   memset (&sk, 0, sizeof sk);
 
   /* Look for flags. */
-  l1 = gcry_sexp_find_token (keyparms, "flags", 0);
+  l1 = sexp_find_token (keyparms, "flags", 0);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
@@ -606,21 +605,21 @@ ecc_check_secret_key (gcry_sexp_t keyparms)
 
   /* Extract the parameters.  */
   if ((flags & PUBKEY_FLAG_PARAM))
 
   /* Extract the parameters.  */
   if ((flags & PUBKEY_FLAG_PARAM))
-    rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
-                                   &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
-                                   &mpi_q, &sk.d, NULL);
+    rc = sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
+                             &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
+                             &mpi_q, &sk.d, NULL);
   else
   else
-    rc = _gcry_sexp_extract_param (keyparms, NULL, "/q?+d",
-                                   &mpi_q, &sk.d, NULL);
+    rc = sexp_extract_param (keyparms, NULL, "/q?+d",
+                             &mpi_q, &sk.d, NULL);
   if (rc)
     goto leave;
 
   /* Add missing parameters using the optional curve parameter.  */
   if (rc)
     goto leave;
 
   /* Add missing parameters using the optional curve parameter.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_update_curve_param (curvename,
       if (curvename)
         {
           rc = _gcry_ecc_update_curve_param (curvename,
@@ -697,17 +696,17 @@ ecc_check_secret_key (gcry_sexp_t keyparms)
 
  leave:
   _gcry_mpi_ec_free (ec);
 
  leave:
   _gcry_mpi_ec_free (ec);
-  gcry_mpi_release (sk.E.p);
-  gcry_mpi_release (sk.E.a);
-  gcry_mpi_release (sk.E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (sk.E.p);
+  _gcry_mpi_release (sk.E.a);
+  _gcry_mpi_release (sk.E.b);
+  _gcry_mpi_release (mpi_g);
   point_free (&sk.E.G);
   point_free (&sk.E.G);
-  gcry_mpi_release (sk.E.n);
-  gcry_mpi_release (mpi_q);
+  _gcry_mpi_release (sk.E.n);
+  _gcry_mpi_release (mpi_q);
   point_free (&sk.Q);
   point_free (&sk.Q);
-  gcry_mpi_release (sk.d);
+  _gcry_mpi_release (sk.d);
   gcry_free (curvename);
   gcry_free (curvename);
-  gcry_sexp_release (l1);
+  sexp_release (l1);
   if (DBG_CIPHER)
     log_debug ("ecc_testkey   => %s\n", gpg_strerror (rc));
   return rc;
   if (DBG_CIPHER)
     log_debug ("ecc_testkey   => %s\n", gpg_strerror (rc));
   return rc;
@@ -743,12 +742,12 @@ ecc_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
    * Extract the key.
    */
   if ((ctx.flags & PUBKEY_FLAG_PARAM))
    * Extract the key.
    */
   if ((ctx.flags & PUBKEY_FLAG_PARAM))
-    rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
-                                   &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
-                                   &mpi_q, &sk.d, NULL);
+    rc = sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?/q?+d",
+                             &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
+                             &mpi_q, &sk.d, NULL);
   else
   else
-    rc = _gcry_sexp_extract_param (keyparms, NULL, "/q?+d",
-                                   &mpi_q, &sk.d, NULL);
+    rc = sexp_extract_param (keyparms, NULL, "/q?+d",
+                             &mpi_q, &sk.d, NULL);
   if (rc)
     goto leave;
   if (mpi_g)
   if (rc)
     goto leave;
   if (mpi_g)
@@ -759,11 +758,11 @@ ecc_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
@@ -806,48 +805,48 @@ ecc_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     }
 
 
     }
 
 
-  sig_r = gcry_mpi_new (0);
-  sig_s = gcry_mpi_new (0);
+  sig_r = mpi_new (0);
+  sig_s = mpi_new (0);
   if ((ctx.flags & PUBKEY_FLAG_EDDSA))
     {
       /* EdDSA requires the public key.  */
       rc = _gcry_ecc_eddsa_sign (data, &sk, sig_r, sig_s, ctx.hash_algo, mpi_q);
       if (!rc)
   if ((ctx.flags & PUBKEY_FLAG_EDDSA))
     {
       /* EdDSA requires the public key.  */
       rc = _gcry_ecc_eddsa_sign (data, &sk, sig_r, sig_s, ctx.hash_algo, mpi_q);
       if (!rc)
-        rc = gcry_sexp_build (r_sig, NULL,
-                              "(sig-val(eddsa(r%M)(s%M)))", sig_r, sig_s);
+        rc = sexp_build (r_sig, NULL,
+                         "(sig-val(eddsa(r%M)(s%M)))", sig_r, sig_s);
     }
   else if ((ctx.flags & PUBKEY_FLAG_GOST))
     {
       rc = _gcry_ecc_gost_sign (data, &sk, sig_r, sig_s);
       if (!rc)
     }
   else if ((ctx.flags & PUBKEY_FLAG_GOST))
     {
       rc = _gcry_ecc_gost_sign (data, &sk, sig_r, sig_s);
       if (!rc)
-        rc = gcry_sexp_build (r_sig, NULL,
-                              "(sig-val(gost(r%M)(s%M)))", sig_r, sig_s);
+        rc = sexp_build (r_sig, NULL,
+                         "(sig-val(gost(r%M)(s%M)))", sig_r, sig_s);
     }
   else
     {
       rc = _gcry_ecc_ecdsa_sign (data, &sk, sig_r, sig_s,
                                  ctx.flags, ctx.hash_algo);
       if (!rc)
     }
   else
     {
       rc = _gcry_ecc_ecdsa_sign (data, &sk, sig_r, sig_s,
                                  ctx.flags, ctx.hash_algo);
       if (!rc)
-        rc = gcry_sexp_build (r_sig, NULL,
-                              "(sig-val(ecdsa(r%M)(s%M)))", sig_r, sig_s);
+        rc = sexp_build (r_sig, NULL,
+                         "(sig-val(ecdsa(r%M)(s%M)))", sig_r, sig_s);
     }
 
 
  leave:
     }
 
 
  leave:
-  gcry_mpi_release (sk.E.p);
-  gcry_mpi_release (sk.E.a);
-  gcry_mpi_release (sk.E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (sk.E.p);
+  _gcry_mpi_release (sk.E.a);
+  _gcry_mpi_release (sk.E.b);
+  _gcry_mpi_release (mpi_g);
   point_free (&sk.E.G);
   point_free (&sk.E.G);
-  gcry_mpi_release (sk.E.n);
-  gcry_mpi_release (mpi_q);
+  _gcry_mpi_release (sk.E.n);
+  _gcry_mpi_release (mpi_q);
   point_free (&sk.Q);
   point_free (&sk.Q);
-  gcry_mpi_release (sk.d);
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
+  _gcry_mpi_release (sk.d);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
   gcry_free (curvename);
   gcry_free (curvename);
-  gcry_mpi_release (data);
-  gcry_sexp_release (l1);
+  _gcry_mpi_release (data);
+  sexp_release (l1);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("ecc_sign      => %s\n", gpg_strerror (rc));
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("ecc_sign      => %s\n", gpg_strerror (rc));
@@ -887,9 +886,8 @@ ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
   rc = _gcry_pk_util_preparse_sigval (s_sig, ecc_names, &l1, &sigflags);
   if (rc)
     goto leave;
   rc = _gcry_pk_util_preparse_sigval (s_sig, ecc_names, &l1, &sigflags);
   if (rc)
     goto leave;
-  rc = _gcry_sexp_extract_param (l1, NULL,
-                                 (sigflags & PUBKEY_FLAG_EDDSA)? "/rs":"rs",
-                                 &sig_r, &sig_s, NULL);
+  rc = sexp_extract_param (l1, NULL, (sigflags & PUBKEY_FLAG_EDDSA)? "/rs":"rs",
+                           &sig_r, &sig_s, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -908,12 +906,12 @@ ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
    * Extract the key.
    */
   if ((ctx.flags & PUBKEY_FLAG_PARAM))
    * Extract the key.
    */
   if ((ctx.flags & PUBKEY_FLAG_PARAM))
-    rc = _gcry_sexp_extract_param (s_keyparms, NULL, "-p?a?b?g?n?/q",
-                                   &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
-                                   &mpi_q, NULL);
+    rc = sexp_extract_param (s_keyparms, NULL, "-p?a?b?g?n?/q",
+                             &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
+                             &mpi_q, NULL);
   else
   else
-    rc = _gcry_sexp_extract_param (s_keyparms, NULL, "/q",
-                                   &mpi_q, NULL);
+    rc = sexp_extract_param (s_keyparms, NULL, "/q",
+                             &mpi_q, NULL);
   if (rc)
     goto leave;
   if (mpi_g)
   if (rc)
     goto leave;
   if (mpi_g)
@@ -924,11 +922,11 @@ ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (s_keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (s_keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
@@ -1017,16 +1015,15 @@ ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
 
           qbits = mpi_get_nbits (pk.E.n);
 
 
           qbits = mpi_get_nbits (pk.E.n);
 
-          abuf = gcry_mpi_get_opaque (data, &abits);
-          rc = gpg_err_code (gcry_mpi_scan (&a, GCRYMPI_FMT_USG,
-                                            abuf, (abits+7)/8, NULL));
+          abuf = mpi_get_opaque (data, &abits);
+          rc = _gcry_mpi_scan (&a, GCRYMPI_FMT_USG, abuf, (abits+7)/8, NULL);
           if (!rc)
             {
               if (abits > qbits)
           if (!rc)
             {
               if (abits > qbits)
-                gcry_mpi_rshift (a, a, abits - qbits);
+                mpi_rshift (a, a, abits - qbits);
 
               rc = _gcry_ecc_ecdsa_verify (a, &pk, sig_r, sig_s);
 
               rc = _gcry_ecc_ecdsa_verify (a, &pk, sig_r, sig_s);
-              gcry_mpi_release (a);
+              _gcry_mpi_release (a);
             }
         }
       else
             }
         }
       else
@@ -1034,19 +1031,19 @@ ecc_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
     }
 
  leave:
     }
 
  leave:
-  gcry_mpi_release (pk.E.p);
-  gcry_mpi_release (pk.E.a);
-  gcry_mpi_release (pk.E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (pk.E.p);
+  _gcry_mpi_release (pk.E.a);
+  _gcry_mpi_release (pk.E.b);
+  _gcry_mpi_release (mpi_g);
   point_free (&pk.E.G);
   point_free (&pk.E.G);
-  gcry_mpi_release (pk.E.n);
-  gcry_mpi_release (mpi_q);
+  _gcry_mpi_release (pk.E.n);
+  _gcry_mpi_release (mpi_q);
   point_free (&pk.Q);
   point_free (&pk.Q);
-  gcry_mpi_release (data);
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
+  _gcry_mpi_release (data);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
   gcry_free (curvename);
   gcry_free (curvename);
-  gcry_sexp_release (l1);
+  sexp_release (l1);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("ecc_verify    => %s\n", rc?gpg_strerror (rc):"Good");
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("ecc_verify    => %s\n", rc?gpg_strerror (rc):"Good");
@@ -1119,9 +1116,9 @@ ecc_encrypt_raw (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
   /*
    * Extract the key.
    */
   /*
    * Extract the key.
    */
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+q",
-                                 &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
-                                 &mpi_q, NULL);
+  rc = sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+q",
+                           &pk.E.p, &pk.E.a, &pk.E.b, &mpi_g, &pk.E.n,
+                           &mpi_q, NULL);
   if (rc)
     goto leave;
   if (mpi_g)
   if (rc)
     goto leave;
   if (mpi_g)
@@ -1132,11 +1129,11 @@ ecc_encrypt_raw (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &pk.E, NULL);
@@ -1214,21 +1211,20 @@ ecc_encrypt_raw (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     point_free (&R);
   }
 
     point_free (&R);
   }
 
-  rc = gcry_sexp_build (r_ciph, NULL, "(enc-val(ecdh(s%m)(e%m)))",
-                        mpi_s, mpi_e);
+  rc = sexp_build (r_ciph, NULL, "(enc-val(ecdh(s%m)(e%m)))", mpi_s, mpi_e);
 
  leave:
 
  leave:
-  gcry_mpi_release (pk.E.p);
-  gcry_mpi_release (pk.E.a);
-  gcry_mpi_release (pk.E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (pk.E.p);
+  _gcry_mpi_release (pk.E.a);
+  _gcry_mpi_release (pk.E.b);
+  _gcry_mpi_release (mpi_g);
   point_free (&pk.E.G);
   point_free (&pk.E.G);
-  gcry_mpi_release (pk.E.n);
-  gcry_mpi_release (mpi_q);
+  _gcry_mpi_release (pk.E.n);
+  _gcry_mpi_release (mpi_q);
   point_free (&pk.Q);
   point_free (&pk.Q);
-  gcry_mpi_release (data);
-  gcry_mpi_release (mpi_s);
-  gcry_mpi_release (mpi_e);
+  _gcry_mpi_release (data);
+  _gcry_mpi_release (mpi_s);
+  _gcry_mpi_release (mpi_e);
   gcry_free (curvename);
   _gcry_mpi_ec_free (ec);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   gcry_free (curvename);
   _gcry_mpi_ec_free (ec);
   _gcry_pk_util_free_encoding_ctx (&ctx);
@@ -1273,7 +1269,7 @@ ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
   rc = _gcry_pk_util_preparse_encval (s_data, ecc_names, &l1, &ctx);
   if (rc)
     goto leave;
   rc = _gcry_pk_util_preparse_encval (s_data, ecc_names, &l1, &ctx);
   if (rc)
     goto leave;
-  rc = _gcry_sexp_extract_param (l1, NULL, "e", &data_e, NULL);
+  rc = sexp_extract_param (l1, NULL, "e", &data_e, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -1287,9 +1283,9 @@ ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
   /*
    * Extract the key.
    */
   /*
    * Extract the key.
    */
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+d",
-                                 &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
-                                 &sk.d, NULL);
+  rc = sexp_extract_param (keyparms, NULL, "-p?a?b?g?n?+d",
+                           &sk.E.p, &sk.E.a, &sk.E.b, &mpi_g, &sk.E.n,
+                           &sk.d, NULL);
   if (rc)
     goto leave;
   if (mpi_g)
   if (rc)
     goto leave;
   if (mpi_g)
@@ -1300,11 +1296,11 @@ ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
         goto leave;
     }
   /* Add missing parameters using the optional curve parameter.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
       if (curvename)
         {
           rc = _gcry_ecc_fill_in_curve (0, curvename, &sk.E, NULL);
@@ -1378,22 +1374,22 @@ ecc_decrypt_raw (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     log_printmpi ("ecc_decrypt  res", r);
 
   if (!rc)
     log_printmpi ("ecc_decrypt  res", r);
 
   if (!rc)
-    rc = gcry_sexp_build (r_plain, NULL, "(value %m)", r);
+    rc = sexp_build (r_plain, NULL, "(value %m)", r);
 
  leave:
   point_free (&R);
   point_free (&kG);
 
  leave:
   point_free (&R);
   point_free (&kG);
-  gcry_mpi_release (r);
-  gcry_mpi_release (sk.E.p);
-  gcry_mpi_release (sk.E.a);
-  gcry_mpi_release (sk.E.b);
-  gcry_mpi_release (mpi_g);
+  _gcry_mpi_release (r);
+  _gcry_mpi_release (sk.E.p);
+  _gcry_mpi_release (sk.E.a);
+  _gcry_mpi_release (sk.E.b);
+  _gcry_mpi_release (mpi_g);
   point_free (&sk.E.G);
   point_free (&sk.E.G);
-  gcry_mpi_release (sk.E.n);
-  gcry_mpi_release (sk.d);
-  gcry_mpi_release (data_e);
-  gcry_free (curvename);
-  gcry_sexp_release (l1);
+  _gcry_mpi_release (sk.E.n);
+  _gcry_mpi_release (sk.d);
+  _gcry_mpi_release (data_e);
+  _gcry_free (curvename);
+  sexp_release (l1);
   _gcry_mpi_ec_free (ec);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
   _gcry_mpi_ec_free (ec);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
@@ -1425,15 +1421,15 @@ ecc_get_nbits (gcry_sexp_t parms)
   unsigned int nbits = 0;
   char *curve;
 
   unsigned int nbits = 0;
   char *curve;
 
-  l1 = gcry_sexp_find_token (parms, "p", 1);
+  l1 = sexp_find_token (parms, "p", 1);
   if (!l1)
     { /* Parameter P not found - check whether we have "curve".  */
   if (!l1)
     { /* Parameter P not found - check whether we have "curve".  */
-      l1 = gcry_sexp_find_token (parms, "curve", 5);
+      l1 = sexp_find_token (parms, "curve", 5);
       if (!l1)
         return 0; /* Neither P nor CURVE found.  */
 
       if (!l1)
         return 0; /* Neither P nor CURVE found.  */
 
-      curve = _gcry_sexp_nth_string (l1, 1);
-      gcry_sexp_release (l1);
+      curve = sexp_nth_string (l1, 1);
+      sexp_release (l1);
       if (!curve)
         return 0;  /* No curve name given (or out of core). */
 
       if (!curve)
         return 0;  /* No curve name given (or out of core). */
 
@@ -1443,12 +1439,12 @@ ecc_get_nbits (gcry_sexp_t parms)
     }
   else
     {
     }
   else
     {
-      p = gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-      gcry_sexp_release (l1);
+      p = sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+      sexp_release (l1);
       if (p)
         {
           nbits = mpi_get_nbits (p);
       if (p)
         {
           nbits = mpi_get_nbits (p);
-          gcry_mpi_release (p);
+          _gcry_mpi_release (p);
         }
     }
   return nbits;
         }
     }
   return nbits;
@@ -1476,7 +1472,7 @@ compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparms)
 
 
   /* Look for flags. */
 
 
   /* Look for flags. */
-  l1 = gcry_sexp_find_token (keyparms, "flags", 0);
+  l1 = sexp_find_token (keyparms, "flags", 0);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
   if (l1)
     {
       rc = _gcry_pk_util_parse_flaglist (l1, &flags, NULL);
@@ -1488,35 +1484,35 @@ compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparms)
   if ((flags & PUBKEY_FLAG_PARAM))
     {
       if ((flags & PUBKEY_FLAG_EDDSA))
   if ((flags & PUBKEY_FLAG_PARAM))
     {
       if ((flags & PUBKEY_FLAG_EDDSA))
-        rc = _gcry_sexp_extract_param (keyparms, NULL, "p?a?b?g?n?/q",
-                                       &values[0], &values[1], &values[2],
-                                       &values[3], &values[4], &values[5],
-                                       NULL);
+        rc = sexp_extract_param (keyparms, NULL, "p?a?b?g?n?/q",
+                                 &values[0], &values[1], &values[2],
+                                 &values[3], &values[4], &values[5],
+                                 NULL);
       else
       else
-        rc = _gcry_sexp_extract_param (keyparms, NULL, "p?a?b?g?n?q",
-                                       &values[0], &values[1], &values[2],
-                                       &values[3], &values[4], &values[5],
-                                       NULL);
+        rc = sexp_extract_param (keyparms, NULL, "p?a?b?g?n?q",
+                                 &values[0], &values[1], &values[2],
+                                 &values[3], &values[4], &values[5],
+                                 NULL);
     }
   else
     {
       if ((flags & PUBKEY_FLAG_EDDSA))
     }
   else
     {
       if ((flags & PUBKEY_FLAG_EDDSA))
-        rc = _gcry_sexp_extract_param (keyparms, NULL, "/q",
-                                       &values[5], NULL);
+        rc = sexp_extract_param (keyparms, NULL, "/q",
+                                 &values[5], NULL);
       else
       else
-        rc = _gcry_sexp_extract_param (keyparms, NULL, "q",
-                                       &values[5], NULL);
+        rc = sexp_extract_param (keyparms, NULL, "q",
+                                 &values[5], NULL);
     }
   if (rc)
     goto leave;
 
   /* Check whether a curve parameter is available and use that to fill
      in missing values.  */
     }
   if (rc)
     goto leave;
 
   /* Check whether a curve parameter is available and use that to fill
      in missing values.  */
-  gcry_sexp_release (l1);
-  l1 = gcry_sexp_find_token (keyparms, "curve", 5);
+  sexp_release (l1);
+  l1 = sexp_find_token (keyparms, "curve", 5);
   if (l1)
     {
   if (l1)
     {
-      curvename = gcry_sexp_nth_string (l1, 1);
+      curvename = sexp_nth_string (l1, 1);
       if (curvename)
         {
           rc = _gcry_ecc_update_curve_param (curvename,
       if (curvename)
         {
           rc = _gcry_ecc_update_curve_param (curvename,
@@ -1577,12 +1573,12 @@ compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparms)
           const unsigned char *raw;
           unsigned int n;
 
           const unsigned char *raw;
           unsigned int n;
 
-          raw = gcry_mpi_get_opaque (values[idx], &n);
+          raw = mpi_get_opaque (values[idx], &n);
           n = (n + 7)/8;
           snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], n);
           n = (n + 7)/8;
           snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], n);
-          gcry_md_write (md, buf, strlen (buf));
-          gcry_md_write (md, raw, n);
-          gcry_md_write (md, ")", 1);
+          _gcry_md_write (md, buf, strlen (buf));
+          _gcry_md_write (md, raw, n);
+          _gcry_md_write (md, ")", 1);
         }
       else
         {
         }
       else
         {
@@ -1596,16 +1592,16 @@ compute_keygrip (gcry_md_hd_t md, gcry_sexp_t keyparms)
               goto leave;
             }
           snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
               goto leave;
             }
           snprintf (buf, sizeof buf, "(1:%c%u:", names[idx], rawmpilen);
-          gcry_md_write (md, buf, strlen (buf));
-          gcry_md_write (md, rawmpi, rawmpilen);
-          gcry_md_write (md, ")", 1);
+          _gcry_md_write (md, buf, strlen (buf));
+          _gcry_md_write (md, rawmpi, rawmpilen);
+          _gcry_md_write (md, ")", 1);
           gcry_free (rawmpi);
         }
     }
 
  leave:
   gcry_free (curvename);
           gcry_free (rawmpi);
         }
     }
 
  leave:
   gcry_free (curvename);
-  gcry_sexp_release (l1);
+  sexp_release (l1);
   for (idx = 0; idx < N_COMPONENTS; idx++)
     _gcry_mpi_release (values[idx]);
 
   for (idx = 0; idx < N_COMPONENTS; idx++)
     _gcry_mpi_release (values[idx]);
 
@@ -1661,7 +1657,7 @@ _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
                                         &encpk, &encpklen);
       if (rc)
         goto leave;
                                         &encpk, &encpklen);
       if (rc)
         goto leave;
-      mpi_Q = gcry_mpi_set_opaque (NULL, encpk, encpklen*8);
+      mpi_Q = mpi_set_opaque (NULL, encpk, encpklen*8);
       encpk = NULL;
     }
   else
       encpk = NULL;
     }
   else
@@ -1680,18 +1676,16 @@ _gcry_pk_ecc_get_sexp (gcry_sexp_t *r_sexp, int mode, mpi_ec_t ec)
   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
     {
       /* Let's return a private key. */
   if (ec->d && (!mode || mode == GCRY_PK_GET_SECKEY))
     {
       /* Let's return a private key. */
-      rc = gcry_sexp_build
-        (r_sexp, NULL,
-         "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
-         ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
+      rc = sexp_build (r_sexp, NULL,
+                       "(private-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)(d%m)))",
+                       ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q, ec->d);
     }
   else if (ec->Q)
     {
       /* Let's return a public key.  */
     }
   else if (ec->Q)
     {
       /* Let's return a public key.  */
-      rc = gcry_sexp_build
-        (r_sexp, NULL,
-         "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
-         ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
+      rc = sexp_build (r_sexp, NULL,
+                       "(public-key(ecc(p%m)(a%m)(b%m)(g%m)(n%m)(q%m)))",
+                       ec->p, ec->a, ec->b, mpi_G, ec->n, mpi_Q);
     }
   else
     rc = GPG_ERR_BAD_CRYPT_CTX;
     }
   else
     rc = GPG_ERR_BAD_CRYPT_CTX;
index 432ba6f..beef8e4 100644 (file)
@@ -141,17 +141,17 @@ static int
 test_keys ( ELG_secret_key *sk, unsigned int nbits, int nodie )
 {
   ELG_public_key pk;
 test_keys ( ELG_secret_key *sk, unsigned int nbits, int nodie )
 {
   ELG_public_key pk;
-  gcry_mpi_t test = gcry_mpi_new ( 0 );
-  gcry_mpi_t out1_a = gcry_mpi_new ( nbits );
-  gcry_mpi_t out1_b = gcry_mpi_new ( nbits );
-  gcry_mpi_t out2 = gcry_mpi_new ( nbits );
+  gcry_mpi_t test   = mpi_new ( 0 );
+  gcry_mpi_t out1_a = mpi_new ( nbits );
+  gcry_mpi_t out1_b = mpi_new ( nbits );
+  gcry_mpi_t out2   = mpi_new ( nbits );
   int failed = 0;
 
   pk.p = sk->p;
   pk.g = sk->g;
   pk.y = sk->y;
 
   int failed = 0;
 
   pk.p = sk->p;
   pk.g = sk->g;
   pk.y = sk->y;
 
-  gcry_mpi_randomize ( test, nbits, GCRY_WEAK_RANDOM );
+  _gcry_mpi_randomize ( test, nbits, GCRY_WEAK_RANDOM );
 
   do_encrypt ( out1_a, out1_b, test, &pk );
   decrypt ( out2, out1_a, out1_b, sk );
 
   do_encrypt ( out1_a, out1_b, test, &pk );
   decrypt ( out2, out1_a, out1_b, sk );
@@ -162,10 +162,10 @@ test_keys ( ELG_secret_key *sk, unsigned int nbits, int nodie )
   if ( !verify( out1_a, out1_b, test, &pk ) )
     failed |= 2;
 
   if ( !verify( out1_a, out1_b, test, &pk ) )
     failed |= 2;
 
-  gcry_mpi_release ( test );
-  gcry_mpi_release ( out1_a );
-  gcry_mpi_release ( out1_b );
-  gcry_mpi_release ( out2 );
+  _gcry_mpi_release ( test );
+  _gcry_mpi_release ( out1_a );
+  _gcry_mpi_release ( out1_b );
+  _gcry_mpi_release ( out2 );
 
   if (failed && !nodie)
     log_fatal ("Elgamal test key for %s %s failed\n",
 
   if (failed && !nodie)
     log_fatal ("Elgamal test key for %s %s failed\n",
@@ -217,7 +217,7 @@ gen_k( gcry_mpi_t p, int small_k )
       if( !rndbuf || nbits < 32 )
         {
           gcry_free(rndbuf);
       if( !rndbuf || nbits < 32 )
         {
           gcry_free(rndbuf);
-          rndbuf = gcry_random_bytes_secure( nbytes, GCRY_STRONG_RANDOM );
+          rndbuf = _gcry_random_bytes_secure( nbytes, GCRY_STRONG_RANDOM );
         }
       else
         {
         }
       else
         {
@@ -226,7 +226,7 @@ gen_k( gcry_mpi_t p, int small_k )
              to get_random_bytes() and use this the here maybe it is
              easier to do this directly in random.c Anyway, it is
              highly inlikely that we will ever reach this code. */
              to get_random_bytes() and use this the here maybe it is
              easier to do this directly in random.c Anyway, it is
              highly inlikely that we will ever reach this code. */
-          char *pp = gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
+          char *pp = _gcry_random_bytes_secure( 4, GCRY_STRONG_RANDOM );
           memcpy( rndbuf, pp, 4 );
           gcry_free(pp);
        }
           memcpy( rndbuf, pp, 4 );
           gcry_free(pp);
        }
@@ -246,7 +246,7 @@ gen_k( gcry_mpi_t p, int small_k )
                 progress('-');
               break; /* no */
             }
                 progress('-');
               break; /* no */
             }
-          if (gcry_mpi_gcd( temp, k, p_1 ))
+          if (mpi_gcd( temp, k, p_1 ))
             goto found;  /* okay, k is relative prime to (p-1) */
           mpi_add_ui( k, k, 1 );
           if( DBG_CIPHER )
             goto found;  /* okay, k is relative prime to (p-1) */
           mpi_add_ui( k, k, 1 );
           if( DBG_CIPHER )
@@ -280,7 +280,7 @@ generate ( ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
   unsigned int xbits;
   byte *rndbuf;
 
   unsigned int xbits;
   byte *rndbuf;
 
-  p_min1 = gcry_mpi_new ( nbits );
+  p_min1 = mpi_new ( nbits );
   qbits = wiener_map( nbits );
   if( qbits & 1 ) /* better have a even one */
     qbits++;
   qbits = wiener_map( nbits );
   if( qbits & 1 ) /* better have a even one */
     qbits++;
@@ -303,7 +303,7 @@ generate ( ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
   xbits = qbits * 3 / 2;
   if( xbits >= nbits )
     BUG();
   xbits = qbits * 3 / 2;
   if( xbits >= nbits )
     BUG();
-  x = gcry_mpi_snew ( xbits );
+  x = mpi_snew ( xbits );
   if( DBG_CIPHER )
     log_debug("choosing a random x of size %u\n", xbits );
   rndbuf = NULL;
   if( DBG_CIPHER )
     log_debug("choosing a random x of size %u\n", xbits );
   rndbuf = NULL;
@@ -316,21 +316,20 @@ generate ( ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
           if( xbits < 16 ) /* should never happen ... */
             {
               gcry_free(rndbuf);
           if( xbits < 16 ) /* should never happen ... */
             {
               gcry_free(rndbuf);
-              rndbuf = gcry_random_bytes_secure( (xbits+7)/8,
-                                                 GCRY_VERY_STRONG_RANDOM );
+              rndbuf = _gcry_random_bytes_secure ((xbits+7)/8,
+                                                  GCRY_VERY_STRONG_RANDOM);
             }
           else
             {
             }
           else
             {
-              char *r = gcry_random_bytes_secure( 2,
-                                                  GCRY_VERY_STRONG_RANDOM );
+              char *r = _gcry_random_bytes_secure (2, GCRY_VERY_STRONG_RANDOM);
               memcpy(rndbuf, r, 2 );
               gcry_free(r);
             }
        }
       else
         {
               memcpy(rndbuf, r, 2 );
               gcry_free(r);
             }
        }
       else
         {
-          rndbuf = gcry_random_bytes_secure( (xbits+7)/8,
-                                             GCRY_VERY_STRONG_RANDOM );
+          rndbuf = _gcry_random_bytes_secure ((xbits+7)/8,
+                                              GCRY_VERY_STRONG_RANDOM );
        }
       _gcry_mpi_set_buffer( x, rndbuf, (xbits+7)/8, 0 );
       mpi_clear_highbit( x, xbits+1 );
        }
       _gcry_mpi_set_buffer( x, rndbuf, (xbits+7)/8, 0 );
       mpi_clear_highbit( x, xbits+1 );
@@ -338,8 +337,8 @@ generate ( ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
   while( !( mpi_cmp_ui( x, 0 )>0 && mpi_cmp( x, p_min1 )<0 ) );
   gcry_free(rndbuf);
 
   while( !( mpi_cmp_ui( x, 0 )>0 && mpi_cmp( x, p_min1 )<0 ) );
   gcry_free(rndbuf);
 
-  y = gcry_mpi_new (nbits);
-  gcry_mpi_powm( y, g, x, p );
+  y = mpi_new (nbits);
+  mpi_powm( y, g, x, p );
 
   if( DBG_CIPHER )
     {
 
   if( DBG_CIPHER )
     {
@@ -356,7 +355,7 @@ generate ( ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t **ret_factors )
   sk->y = y;
   sk->x = x;
 
   sk->y = y;
   sk->x = x;
 
-  gcry_mpi_release ( p_min1 );
+  _gcry_mpi_release ( p_min1 );
 
   /* Now we can test our keys (this should never fail!) */
   test_keys ( sk, nbits - 64, 0 );
 
   /* Now we can test our keys (this should never fail!) */
   test_keys ( sk, nbits - 64, 0 );
@@ -391,7 +390,7 @@ generate_using_x (ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t x,
   if ( xbits < 64 || xbits >= nbits )
     return GPG_ERR_INV_VALUE;
 
   if ( xbits < 64 || xbits >= nbits )
     return GPG_ERR_INV_VALUE;
 
-  p_min1 = gcry_mpi_new ( nbits );
+  p_min1 = mpi_new ( nbits );
   qbits  = wiener_map ( nbits );
   if ( (qbits & 1) ) /* Better have an even one.  */
     qbits++;
   qbits  = wiener_map ( nbits );
   if ( (qbits & 1) ) /* Better have an even one.  */
     qbits++;
@@ -403,14 +402,14 @@ generate_using_x (ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t x,
     log_debug ("using a supplied x of size %u", xbits );
   if ( !(mpi_cmp_ui ( x, 0 ) > 0 && mpi_cmp ( x, p_min1 ) <0 ) )
     {
     log_debug ("using a supplied x of size %u", xbits );
   if ( !(mpi_cmp_ui ( x, 0 ) > 0 && mpi_cmp ( x, p_min1 ) <0 ) )
     {
-      gcry_mpi_release ( p_min1 );
-      gcry_mpi_release ( p );
-      gcry_mpi_release ( g );
+      _gcry_mpi_release ( p_min1 );
+      _gcry_mpi_release ( p );
+      _gcry_mpi_release ( g );
       return GPG_ERR_INV_VALUE;
     }
 
       return GPG_ERR_INV_VALUE;
     }
 
-  y = gcry_mpi_new (nbits);
-  gcry_mpi_powm ( y, g, x, p );
+  y = mpi_new (nbits);
+  mpi_powm ( y, g, x, p );
 
   if ( DBG_CIPHER )
     {
 
   if ( DBG_CIPHER )
     {
@@ -425,17 +424,17 @@ generate_using_x (ELG_secret_key *sk, unsigned int nbits, gcry_mpi_t x,
   sk->p = p;
   sk->g = g;
   sk->y = y;
   sk->p = p;
   sk->g = g;
   sk->y = y;
-  sk->x = gcry_mpi_copy (x);
+  sk->x = mpi_copy (x);
 
 
-  gcry_mpi_release ( p_min1 );
+  _gcry_mpi_release ( p_min1 );
 
   /* Now we can test our keys. */
   if ( test_keys ( sk, nbits - 64, 1 ) )
     {
 
   /* Now we can test our keys. */
   if ( test_keys ( sk, nbits - 64, 1 ) )
     {
-      gcry_mpi_release ( sk->p ); sk->p = NULL;
-      gcry_mpi_release ( sk->g ); sk->g = NULL;
-      gcry_mpi_release ( sk->y ); sk->y = NULL;
-      gcry_mpi_release ( sk->x ); sk->x = NULL;
+      _gcry_mpi_release ( sk->p ); sk->p = NULL;
+      _gcry_mpi_release ( sk->g ); sk->g = NULL;
+      _gcry_mpi_release ( sk->y ); sk->y = NULL;
+      _gcry_mpi_release ( sk->x ); sk->x = NULL;
       return GPG_ERR_BAD_SECKEY;
     }
 
       return GPG_ERR_BAD_SECKEY;
     }
 
@@ -453,7 +452,7 @@ check_secret_key( ELG_secret_key *sk )
   int rc;
   gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
   int rc;
   gcry_mpi_t y = mpi_alloc( mpi_get_nlimbs(sk->y) );
 
-  gcry_mpi_powm( y, sk->g, sk->x, sk->p );
+  mpi_powm (y, sk->g, sk->x, sk->p);
   rc = !mpi_cmp( y, sk->y );
   mpi_free( y );
   return rc;
   rc = !mpi_cmp( y, sk->y );
   mpi_free( y );
   return rc;
@@ -471,14 +470,15 @@ do_encrypt(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_public_key *pkey )
    */
 
   k = gen_k( pkey->p, 1 );
    */
 
   k = gen_k( pkey->p, 1 );
-  gcry_mpi_powm( a, pkey->g, k, pkey->p );
+  mpi_powm (a, pkey->g, k, pkey->p);
+
   /* b = (y^k * input) mod p
    *    = ((y^k mod p) * (input mod p)) mod p
    * and because input is < p
    *    = ((y^k mod p) * input) mod p
    */
   /* b = (y^k * input) mod p
    *    = ((y^k mod p) * (input mod p)) mod p
    * and because input is < p
    *    = ((y^k mod p) * input) mod p
    */
-  gcry_mpi_powm( b, pkey->y, k, pkey->p );
-  gcry_mpi_mulm( b, b, input, pkey->p );
+  mpi_powm (b, pkey->y, k, pkey->p);
+  mpi_mulm (b, b, input, pkey->p);
 #if 0
   if( DBG_CIPHER )
     {
 #if 0
   if( DBG_CIPHER )
     {
@@ -502,7 +502,7 @@ decrypt(gcry_mpi_t output, gcry_mpi_t a, gcry_mpi_t b, ELG_secret_key *skey )
   gcry_mpi_t t1 = mpi_alloc_secure( mpi_get_nlimbs( skey->p ) );
 
   /* output = b/(a^x) mod p */
   gcry_mpi_t t1 = mpi_alloc_secure( mpi_get_nlimbs( skey->p ) );
 
   /* output = b/(a^x) mod p */
-  gcry_mpi_powm( t1, a, skey->x, skey->p );
+  mpi_powm( t1, a, skey->x, skey->p );
   mpi_invm( t1, t1, skey->p );
   mpi_mulm( output, b, t1, skey->p );
 #if 0
   mpi_invm( t1, t1, skey->p );
   mpi_mulm( output, b, t1, skey->p );
 #if 0
@@ -539,7 +539,7 @@ sign(gcry_mpi_t a, gcry_mpi_t b, gcry_mpi_t input, ELG_secret_key *skey )
     */
     mpi_sub_ui(p_1, p_1, 1);
     k = gen_k( skey->p, 0 /* no small K ! */ );
     */
     mpi_sub_ui(p_1, p_1, 1);
     k = gen_k( skey->p, 0 /* no small K ! */ );
-    gcry_mpi_powm( a, skey->g, k, skey->p );
+    mpi_powm( a, skey->g, k, skey->p );
     mpi_mul(t, skey->x, a );
     mpi_subm(t, input, t, p_1 );
     mpi_invm(inv, k, p_1 );
     mpi_mul(t, skey->x, a );
     mpi_subm(t, input, t, p_1 );
     mpi_invm(inv, k, p_1 );
@@ -643,11 +643,11 @@ elg_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
     return rc;
 
   /* Parse the optional xvalue element. */
     return rc;
 
   /* Parse the optional xvalue element. */
-  l1 = gcry_sexp_find_token (genparms, "xvalue", 0);
+  l1 = sexp_find_token (genparms, "xvalue", 0);
   if (l1)
     {
   if (l1)
     {
-      xvalue = gcry_sexp_nth_mpi (l1, 1, 0);
-      gcry_sexp_release (l1);
+      xvalue = sexp_nth_mpi (l1, 1, 0);
+      sexp_release (l1);
       if (!xvalue)
         return GPG_ERR_BAD_MPI;
     }
       if (!xvalue)
         return GPG_ERR_BAD_MPI;
     }
@@ -693,30 +693,30 @@ elg_generate (const gcry_sexp_t genparms, gcry_sexp_t *r_skey)
           arg_list[nfac] = factors + nfac;
         }
       p = stpcpy (p, "))");
           arg_list[nfac] = factors + nfac;
         }
       p = stpcpy (p, "))");
-      rc = gcry_sexp_build_array (&misc_info, NULL, buffer, arg_list);
+      rc = sexp_build_array (&misc_info, NULL, buffer, arg_list);
       gcry_free (arg_list);
       gcry_free (buffer);
       if (rc)
         goto leave;
     }
 
       gcry_free (arg_list);
       gcry_free (buffer);
       if (rc)
         goto leave;
     }
 
-  rc = gcry_sexp_build (r_skey, NULL,
-                        "(key-data"
-                        " (public-key"
-                        "  (elg(p%m)(g%m)(y%m)))"
-                        " (private-key"
-                       "  (elg(p%m)(g%m)(y%m)(x%m)))"
-                        " %S)",
-                        sk.p, sk.g, sk.y,
-                        sk.p, sk.g, sk.y, sk.x,
-                        misc_info);
+  rc = sexp_build (r_skey, NULL,
+                   "(key-data"
+                   " (public-key"
+                   "  (elg(p%m)(g%m)(y%m)))"
+                   " (private-key"
+                   "  (elg(p%m)(g%m)(y%m)(x%m)))"
+                   " %S)",
+                   sk.p, sk.g, sk.y,
+                   sk.p, sk.g, sk.y, sk.x,
+                   misc_info);
 
  leave:
   mpi_free (sk.p);
   mpi_free (sk.g);
   mpi_free (sk.y);
   mpi_free (sk.x);
 
  leave:
   mpi_free (sk.p);
   mpi_free (sk.g);
   mpi_free (sk.y);
   mpi_free (sk.x);
-  gcry_sexp_release (misc_info);
+  sexp_release (misc_info);
   if (factors)
     {
       gcry_mpi_t *mp;
   if (factors)
     {
       gcry_mpi_t *mp;
@@ -735,9 +735,9 @@ elg_check_secret_key (gcry_sexp_t keyparms)
   gcry_err_code_t rc;
   ELG_secret_key sk = {NULL, NULL, NULL, NULL};
 
   gcry_err_code_t rc;
   ELG_secret_key sk = {NULL, NULL, NULL, NULL};
 
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "pgyx",
-                                 &sk.p, &sk.g, &sk.y, &sk.x,
-                                 NULL);
+  rc = sexp_extract_param (keyparms, NULL, "pgyx",
+                           &sk.p, &sk.g, &sk.y, &sk.x,
+                           NULL);
   if (rc)
     goto leave;
 
   if (rc)
     goto leave;
 
@@ -745,10 +745,10 @@ elg_check_secret_key (gcry_sexp_t keyparms)
     rc = GPG_ERR_BAD_SECKEY;
 
  leave:
     rc = GPG_ERR_BAD_SECKEY;
 
  leave:
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
   if (DBG_CIPHER)
     log_debug ("elg_testkey    => %s\n", gpg_strerror (rc));
   return rc;
   if (DBG_CIPHER)
     log_debug ("elg_testkey    => %s\n", gpg_strerror (rc));
   return rc;
@@ -781,8 +781,8 @@ elg_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     }
 
   /* Extract the key.  */
     }
 
   /* Extract the key.  */
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "pgy",
-                                 &pk.p, &pk.g, &pk.y, NULL);
+  rc = sexp_extract_param (keyparms, NULL, "pgy",
+                           &pk.p, &pk.g, &pk.y, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -793,18 +793,18 @@ elg_encrypt (gcry_sexp_t *r_ciph, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     }
 
   /* Do Elgamal computation and build result.  */
     }
 
   /* Do Elgamal computation and build result.  */
-  mpi_a = gcry_mpi_new (0);
-  mpi_b = gcry_mpi_new (0);
+  mpi_a = mpi_new (0);
+  mpi_b = mpi_new (0);
   do_encrypt (mpi_a, mpi_b, data, &pk);
   do_encrypt (mpi_a, mpi_b, data, &pk);
-  rc = gcry_sexp_build (r_ciph, NULL, "(enc-val(elg(a%m)(b%m)))", mpi_a, mpi_b);
+  rc = sexp_build (r_ciph, NULL, "(enc-val(elg(a%m)(b%m)))", mpi_a, mpi_b);
 
  leave:
 
  leave:
-  gcry_mpi_release (mpi_a);
-  gcry_mpi_release (mpi_b);
-  gcry_mpi_release (pk.p);
-  gcry_mpi_release (pk.g);
-  gcry_mpi_release (pk.y);
-  gcry_mpi_release (data);
+  _gcry_mpi_release (mpi_a);
+  _gcry_mpi_release (mpi_b);
+  _gcry_mpi_release (pk.p);
+  _gcry_mpi_release (pk.g);
+  _gcry_mpi_release (pk.y);
+  _gcry_mpi_release (data);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_encrypt   => %s\n", gpg_strerror (rc));
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_encrypt   => %s\n", gpg_strerror (rc));
@@ -832,7 +832,7 @@ elg_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
   rc = _gcry_pk_util_preparse_encval (s_data, elg_names, &l1, &ctx);
   if (rc)
     goto leave;
   rc = _gcry_pk_util_preparse_encval (s_data, elg_names, &l1, &ctx);
   if (rc)
     goto leave;
-  rc = _gcry_sexp_extract_param (l1, NULL, "ab", &data_a, &data_b, NULL);
+  rc = sexp_extract_param (l1, NULL, "ab", &data_a, &data_b, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -847,9 +847,9 @@ elg_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     }
 
   /* Extract the key.  */
     }
 
   /* Extract the key.  */
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "pgyx",
-                                 &sk.p, &sk.g, &sk.y, &sk.x,
-                                 NULL);
+  rc = sexp_extract_param (keyparms, NULL, "pgyx",
+                           &sk.p, &sk.g, &sk.y, &sk.x,
+                           NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -861,7 +861,7 @@ elg_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         log_printmpi ("elg_decrypt    x", sk.x);
     }
 
         log_printmpi ("elg_decrypt    x", sk.x);
     }
 
-  plain = gcry_mpi_snew (ctx.nbits);
+  plain = mpi_snew (ctx.nbits);
   decrypt (plain, data_a, data_b, &sk);
   if (DBG_CIPHER)
     log_printmpi ("elg_decrypt  res", plain);
   decrypt (plain, data_a, data_b, &sk);
   if (DBG_CIPHER)
     log_printmpi ("elg_decrypt  res", plain);
@@ -873,8 +873,7 @@ elg_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
       rc = _gcry_rsa_pkcs1_decode_for_enc (&unpad, &unpadlen, ctx.nbits, plain);
       mpi_free (plain); plain = NULL;
       if (!rc)
       rc = _gcry_rsa_pkcs1_decode_for_enc (&unpad, &unpadlen, ctx.nbits, plain);
       mpi_free (plain); plain = NULL;
       if (!rc)
-        rc = gcry_sexp_build (r_plain, NULL, "(value %b)",
-                              (int)unpadlen, unpad);
+        rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
       break;
 
     case PUBKEY_ENC_OAEP:
       break;
 
     case PUBKEY_ENC_OAEP:
@@ -883,31 +882,30 @@ elg_decrypt (gcry_sexp_t *r_plain, gcry_sexp_t s_data, gcry_sexp_t keyparms)
                                   ctx.label, ctx.labellen);
       mpi_free (plain); plain = NULL;
       if (!rc)
                                   ctx.label, ctx.labellen);
       mpi_free (plain); plain = NULL;
       if (!rc)
-        rc = gcry_sexp_build (r_plain, NULL, "(value %b)",
-                              (int)unpadlen, unpad);
+        rc = sexp_build (r_plain, NULL, "(value %b)", (int)unpadlen, unpad);
       break;
 
     default:
       /* Raw format.  For backward compatibility we need to assume a
          signed mpi by using the sexp format string "%m".  */
       break;
 
     default:
       /* Raw format.  For backward compatibility we need to assume a
          signed mpi by using the sexp format string "%m".  */
-      rc = gcry_sexp_build (r_plain, NULL,
-                            (ctx.flags & PUBKEY_FLAG_LEGACYRESULT)
-                            ? "%m" : "(value %m)",
-                            plain);
+      rc = sexp_build (r_plain, NULL,
+                       (ctx.flags & PUBKEY_FLAG_LEGACYRESULT)
+                       ? "%m" : "(value %m)",
+                       plain);
       break;
     }
 
 
  leave:
   gcry_free (unpad);
       break;
     }
 
 
  leave:
   gcry_free (unpad);
-  gcry_mpi_release (plain);
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
-  gcry_mpi_release (data_a);
-  gcry_mpi_release (data_b);
-  gcry_sexp_release (l1);
+  _gcry_mpi_release (plain);
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
+  _gcry_mpi_release (data_a);
+  _gcry_mpi_release (data_b);
+  sexp_release (l1);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_decrypt    => %s\n", gpg_strerror (rc));
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_decrypt    => %s\n", gpg_strerror (rc));
@@ -941,8 +939,8 @@ elg_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
     }
 
   /* Extract the key.  */
     }
 
   /* Extract the key.  */
-  rc = _gcry_sexp_extract_param (keyparms, NULL, "pgyx",
-                                 &sk.p, &sk.g, &sk.y, &sk.x, NULL);
+  rc = sexp_extract_param (keyparms, NULL, "pgyx",
+                           &sk.p, &sk.g, &sk.y, &sk.x, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -954,24 +952,24 @@ elg_sign (gcry_sexp_t *r_sig, gcry_sexp_t s_data, gcry_sexp_t keyparms)
         log_mpidump ("elg_sign      x", sk.x);
     }
 
         log_mpidump ("elg_sign      x", sk.x);
     }
 
-  sig_r = gcry_mpi_new (0);
-  sig_s = gcry_mpi_new (0);
+  sig_r = mpi_new (0);
+  sig_s = mpi_new (0);
   sign (sig_r, sig_s, data, &sk);
   if (DBG_CIPHER)
     {
       log_mpidump ("elg_sign  sig_r", sig_r);
       log_mpidump ("elg_sign  sig_s", sig_s);
     }
   sign (sig_r, sig_s, data, &sk);
   if (DBG_CIPHER)
     {
       log_mpidump ("elg_sign  sig_r", sig_r);
       log_mpidump ("elg_sign  sig_s", sig_s);
     }
-  rc = gcry_sexp_build (r_sig, NULL, "(sig-val(elg(r%M)(s%M)))", sig_r, sig_s);
+  rc = sexp_build (r_sig, NULL, "(sig-val(elg(r%M)(s%M)))", sig_r, sig_s);
 
  leave:
 
  leave:
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
-  gcry_mpi_release (sk.p);
-  gcry_mpi_release (sk.g);
-  gcry_mpi_release (sk.y);
-  gcry_mpi_release (sk.x);
-  gcry_mpi_release (data);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
+  _gcry_mpi_release (sk.p);
+  _gcry_mpi_release (sk.g);
+  _gcry_mpi_release (sk.y);
+  _gcry_mpi_release (sk.x);
+  _gcry_mpi_release (data);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_sign      => %s\n", gpg_strerror (rc));
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_sign      => %s\n", gpg_strerror (rc));
@@ -1009,7 +1007,7 @@ elg_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
   rc = _gcry_pk_util_preparse_sigval (s_sig, elg_names, &l1, NULL);
   if (rc)
     goto leave;
   rc = _gcry_pk_util_preparse_sigval (s_sig, elg_names, &l1, NULL);
   if (rc)
     goto leave;
-  rc = _gcry_sexp_extract_param (l1, NULL, "rs", &sig_r, &sig_s, NULL);
+  rc = sexp_extract_param (l1, NULL, "rs", &sig_r, &sig_s, NULL);
   if (rc)
     goto leave;
   if (DBG_CIPHER)
   if (rc)
     goto leave;
   if (DBG_CIPHER)
@@ -1019,7 +1017,7 @@ elg_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
     }
 
   /* Extract the key.  */
     }
 
   /* Extract the key.  */
-  rc = _gcry_sexp_extract_param (s_keyparms, NULL, "pgy",
+  rc = sexp_extract_param (s_keyparms, NULL, "pgy",
                                  &pk.p, &pk.g, &pk.y, NULL);
   if (rc)
     goto leave;
                                  &pk.p, &pk.g, &pk.y, NULL);
   if (rc)
     goto leave;
@@ -1035,13 +1033,13 @@ elg_verify (gcry_sexp_t s_sig, gcry_sexp_t s_data, gcry_sexp_t s_keyparms)
     rc = GPG_ERR_BAD_SIGNATURE;
 
  leave:
     rc = GPG_ERR_BAD_SIGNATURE;
 
  leave:
-  gcry_mpi_release (pk.p);
-  gcry_mpi_release (pk.g);
-  gcry_mpi_release (pk.y);
-  gcry_mpi_release (data);
-  gcry_mpi_release (sig_r);
-  gcry_mpi_release (sig_s);
-  gcry_sexp_release (l1);
+  _gcry_mpi_release (pk.p);
+  _gcry_mpi_release (pk.g);
+  _gcry_mpi_release (pk.y);
+  _gcry_mpi_release (data);
+  _gcry_mpi_release (sig_r);
+  _gcry_mpi_release (sig_s);
+  sexp_release (l1);
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_verify    => %s\n", rc?gpg_strerror (rc):"Good");
   _gcry_pk_util_free_encoding_ctx (&ctx);
   if (DBG_CIPHER)
     log_debug ("elg_verify    => %s\n", rc?gpg_strerror (rc):"Good");
@@ -1067,14 +1065,14 @@ elg_get_nbits (gcry_sexp_t parms)
   gcry_mpi_t p;
   unsigned int nbits;
 
   gcry_mpi_t p;
   unsigned int nbits;
 
-  l1 = gcry_sexp_find_token (parms, "p", 1);
+  l1 = sexp_find_token (parms, "p", 1);
   if (!l1)
     return 0; /* Parameter P not found.  */
 
   if (!l1)
     return 0; /* Parameter P not found.  */
 
-  p= gcry_sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
-  gcry_sexp_release (l1);
+  p= sexp_nth_mpi (l1, 1, GCRYMPI_FMT_USG);
+  sexp_release (l1);
   nbits = p? mpi_get_nbits (p) : 0;
   nbits = p? mpi_get_nbits (p) : 0;
-  gcry_mpi_release (p);
+  _gcry_mpi_release (p);
   return nbits;
 }
 
   return nbits;
 }
 
index a32ece7..7c27342 100644 (file)
@@ -718,7 +718,7 @@ _gcry_hmac_selftest (int algo, int extended, selftest_report_func_t report)
 {
   gcry_err_code_t ec = 0;
 
 {
   gcry_err_code_t ec = 0;
 
-  if (!gcry_md_test_algo (algo))
+  if (!_gcry_md_test_algo (algo))
     {
       ec = run_selftests (algo, extended, report);
     }
     {
       ec = run_selftests (algo, extended, report);
     }
index da63574..542752e 100644 (file)
@@ -55,8 +55,7 @@ openpgp_s2k (const void *passphrase, size_t passphraselen,
 
   secmode = gcry_is_secure (passphrase) || gcry_is_secure (keybuffer);
 
 
   secmode = gcry_is_secure (passphrase) || gcry_is_secure (keybuffer);
 
-  ec = gpg_err_code (gcry_md_open (&md, hashalgo,
-                                   secmode? GCRY_MD_FLAG_SECURE : 0));
+  ec = _gcry_md_open (&md, hashalgo, secmode? GCRY_MD_FLAG_SECURE : 0);
   if (ec)
     return ec;
 
   if (ec)
     return ec;
 
@@ -64,9 +63,9 @@ openpgp_s2k (const void *passphrase, size_t passphraselen,
     {
       if (pass)
         {
     {
       if (pass)
         {
-          gcry_md_reset (md);
+          _gcry_md_reset (md);
           for (i=0; i < pass; i++) /* Preset the hash context.  */
           for (i=0; i < pass; i++) /* Preset the hash context.  */
-            gcry_md_putc (md, 0);
+            _gcry_md_putc (md, 0);
        }
 
       if (algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
        }
 
       if (algo == GCRY_KDF_SALTED_S2K || algo == GCRY_KDF_ITERSALTED_S2K)
@@ -83,30 +82,30 @@ openpgp_s2k (const void *passphrase, size_t passphraselen,
 
           while (count > len2)
             {
 
           while (count > len2)
             {
-              gcry_md_write (md, salt, saltlen);
-              gcry_md_write (md, passphrase, passphraselen);
+              _gcry_md_write (md, salt, saltlen);
+              _gcry_md_write (md, passphrase, passphraselen);
               count -= len2;
             }
           if (count < saltlen)
               count -= len2;
             }
           if (count < saltlen)
-            gcry_md_write (md, salt, count);
+            _gcry_md_write (md, salt, count);
           else
             {
           else
             {
-              gcry_md_write (md, salt, saltlen);
+              _gcry_md_write (md, salt, saltlen);
               count -= saltlen;
               count -= saltlen;
-              gcry_md_write (md, passphrase, count);
+              _gcry_md_write (md, passphrase, count);
             }
         }
       else
             }
         }
       else
-        gcry_md_write (md, passphrase, passphraselen);
+        _gcry_md_write (md, passphrase, passphraselen);
 
 
-      gcry_md_final (md);
-      i = gcry_md_get_algo_dlen (hashalgo);
+      _gcry_md_final (md);
+      i = _gcry_md_get_algo_dlen (hashalgo);
       if (i > keysize - used)
         i = keysize - used;
       if (i > keysize - used)
         i = keysize - used;
-      memcpy (key+used, gcry_md_read (md, hashalgo), i);
+      memcpy (key+used, _gcry_md_read (md, hashalgo), i);
       used += i;
     }
       used += i;
     }
-  gcry_md_close (md);
+  _gcry_md_close (md);
   return 0;
 }
 
   return 0;
 }
 
@@ -146,7 +145,7 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
   if (!salt || !iterations || !dklen)
     return GPG_ERR_INV_VALUE;
 
   if (!salt || !iterations || !dklen)
     return GPG_ERR_INV_VALUE;
 
-  hlen = gcry_md_get_algo_dlen (hashalgo);
+  hlen = _gcry_md_get_algo_dlen (hashalgo);
   if (!hlen)
     return GPG_ERR_DIGEST_ALGO;
 
   if (!hlen)
     return GPG_ERR_DIGEST_ALGO;
 
@@ -168,9 +167,8 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
   tbuf = sbuf + saltlen + 4;
   ubuf = tbuf + hlen;
 
   tbuf = sbuf + saltlen + 4;
   ubuf = tbuf + hlen;
 
-  ec = gpg_err_code (gcry_md_open (&md, hashalgo,
-                                   (GCRY_MD_FLAG_HMAC
-                                    | (secmode?GCRY_MD_FLAG_SECURE:0))));
+  ec = _gcry_md_open (&md, hashalgo, (GCRY_MD_FLAG_HMAC
+                                      | (secmode?GCRY_MD_FLAG_SECURE:0)));
   if (ec)
     {
       gcry_free (sbuf);
   if (ec)
     {
       gcry_free (sbuf);
@@ -183,10 +181,10 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
     {
       for (iter = 0; iter < iterations; iter++)
         {
     {
       for (iter = 0; iter < iterations; iter++)
         {
-          ec = gpg_err_code (gcry_md_setkey (md, passphrase, passphraselen));
+          ec = _gcry_md_setkey (md, passphrase, passphraselen);
           if (ec)
             {
           if (ec)
             {
-              gcry_md_close (md);
+              _gcry_md_close (md);
               gcry_free (sbuf);
               return ec;
             }
               gcry_free (sbuf);
               return ec;
             }
@@ -196,14 +194,14 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
               sbuf[saltlen + 1] = (lidx >> 16);
               sbuf[saltlen + 2] = (lidx >> 8);
               sbuf[saltlen + 3] = lidx;
               sbuf[saltlen + 1] = (lidx >> 16);
               sbuf[saltlen + 2] = (lidx >> 8);
               sbuf[saltlen + 3] = lidx;
-              gcry_md_write (md, sbuf, saltlen + 4);
-              memcpy (ubuf, gcry_md_read (md, 0), hlen);
+              _gcry_md_write (md, sbuf, saltlen + 4);
+              memcpy (ubuf, _gcry_md_read (md, 0), hlen);
               memcpy (tbuf, ubuf, hlen);
             }
           else /* Compute U_(2..c):  */
             {
               memcpy (tbuf, ubuf, hlen);
             }
           else /* Compute U_(2..c):  */
             {
-              gcry_md_write (md, ubuf, hlen);
-              memcpy (ubuf, gcry_md_read (md, 0), hlen);
+              _gcry_md_write (md, ubuf, hlen);
+              memcpy (ubuf, _gcry_md_read (md, 0), hlen);
               for (i=0; i < hlen; i++)
                 tbuf[i] ^= ubuf[i];
             }
               for (i=0; i < hlen; i++)
                 tbuf[i] ^= ubuf[i];
             }
@@ -217,7 +215,7 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
         }
     }
 
         }
     }
 
-  gcry_md_close (md);
+  _gcry_md_close (md);
   gcry_free (sbuf);
   return 0;
 }
   gcry_free (sbuf);
   return 0;
 }
@@ -234,12 +232,12 @@ _gcry_kdf_pkdf2 (const void *passphrase, size_t passphraselen,
    is a salt as needed by most KDF algorithms.  ITERATIONS is a
    positive integer parameter to most KDFs.  0 is returned on success,
    or an error code on failure.  */
    is a salt as needed by most KDF algorithms.  ITERATIONS is a
    positive integer parameter to most KDFs.  0 is returned on success,
    or an error code on failure.  */
-gpg_error_t
-gcry_kdf_derive (const void *passphrase, size_t passphraselen,
-                 int algo, int subalgo,
-                 const void *salt, size_t saltlen,
-                 unsigned long iterations,
-                 size_t keysize, void *keybuffer)
+gpg_err_code_t
+_gcry_kdf_derive (const void *passphrase, size_t passphraselen,
+                  int algo, int subalgo,
+                  const void *salt, size_t saltlen,
+                  unsigned long iterations,
+                  size_t keysize, void *keybuffer)
 {
   gpg_err_code_t ec;
 
 {
   gpg_err_code_t ec;
 
@@ -296,5 +294,5 @@ gcry_kdf_derive (const void *passphrase, size_t passphraselen,
     }
 
  leave:
     }
 
  leave:
-  return gpg_error (ec);
+  return ec;
 }
 }
index fddce39..69a2f17 100644 (file)
@@ -103,7 +103,7 @@ cmac_setkey (gcry_mac_hd_t h, const unsigned char *key, size_t keylen)
 static gcry_err_code_t
 cmac_reset (gcry_mac_hd_t h)
 {
 static gcry_err_code_t
 cmac_reset (gcry_mac_hd_t h)
 {
-  return gcry_cipher_reset (h->u.cmac.ctx);
+  return _gcry_cipher_reset (h->u.cmac.ctx);
 }
 
 
 }
 
 
index e040bfe..18d56b5 100644 (file)
@@ -97,7 +97,7 @@ gmac_setiv (gcry_mac_hd_t h, const unsigned char *iv, size_t ivlen)
 static gcry_err_code_t
 gmac_reset (gcry_mac_hd_t h)
 {
 static gcry_err_code_t
 gmac_reset (gcry_mac_hd_t h)
 {
-  return gcry_cipher_reset (h->u.gmac.ctx);
+  return _gcry_cipher_reset (h->u.gmac.ctx);
 }
 
 
 }
 
 
index 46b21b1..15c613d 100644 (file)
@@ -79,7 +79,7 @@ hmac_open (gcry_mac_hd_t h)
   flags = GCRY_MD_FLAG_HMAC;
   flags |= (secure ? GCRY_MD_FLAG_SECURE : 0);
 
   flags = GCRY_MD_FLAG_HMAC;
   flags |= (secure ? GCRY_MD_FLAG_SECURE : 0);
 
-  err = gcry_md_open (&hd, md_algo, flags);
+  err = _gcry_md_open (&hd, md_algo, flags);
   if (err)
     return err;
 
   if (err)
     return err;
 
@@ -92,7 +92,7 @@ hmac_open (gcry_mac_hd_t h)
 static void
 hmac_close (gcry_mac_hd_t h)
 {
 static void
 hmac_close (gcry_mac_hd_t h)
 {
-  gcry_md_close (h->u.hmac.md_ctx);
+  _gcry_md_close (h->u.hmac.md_ctx);
   h->u.hmac.md_ctx = NULL;
 }
 
   h->u.hmac.md_ctx = NULL;
 }
 
@@ -100,14 +100,14 @@ hmac_close (gcry_mac_hd_t h)
 static gcry_err_code_t
 hmac_setkey (gcry_mac_hd_t h, const unsigned char *key, size_t keylen)
 {
 static gcry_err_code_t
 hmac_setkey (gcry_mac_hd_t h, const unsigned char *key, size_t keylen)
 {
-  return gcry_md_setkey (h->u.hmac.md_ctx, key, keylen);
+  return _gcry_md_setkey (h->u.hmac.md_ctx, key, keylen);
 }
 
 
 static gcry_err_code_t
 hmac_reset (gcry_mac_hd_t h)
 {
 }
 
 
 static gcry_err_code_t
 hmac_reset (gcry_mac_hd_t h)
 {
-  gcry_md_reset (h->u.hmac.md_ctx);
+  _gcry_md_reset (h->u.hmac.md_ctx);
   return 0;
 }
 
   return 0;
 }
 
@@ -115,7 +115,7 @@ hmac_reset (gcry_mac_hd_t h)
 static gcry_err_code_t
 hmac_write (gcry_mac_hd_t h, const unsigned char *buf, size_t buflen)
 {
 static gcry_err_code_t
 hmac_write (gcry_mac_hd_t h, const unsigned char *buf, size_t buflen)
 {
-  gcry_md_write (h->u.hmac.md_ctx, buf, buflen);
+  _gcry_md_write (h->u.hmac.md_ctx, buf, buflen);
   return 0;
 }
 
   return 0;
 }
 
@@ -126,8 +126,8 @@ hmac_read (gcry_mac_hd_t h, unsigned char *outbuf, size_t * outlen)
   unsigned int dlen;
   const unsigned char *digest;
 
   unsigned int dlen;
   const unsigned char *digest;
 
-  dlen = gcry_md_get_algo_dlen (h->u.hmac.md_algo);
-  digest = gcry_md_read (h->u.hmac.md_ctx, h->u.hmac.md_algo);
+  dlen = _gcry_md_get_algo_dlen (h->u.hmac.md_algo);
+  digest = _gcry_md_read (h->u.hmac.md_ctx, h->u.hmac.md_algo);
 
   if (*outlen <= dlen)
     buf_cpy (outbuf, digest, *outlen);
 
   if (*outlen <= dlen)
     buf_cpy (outbuf, digest, *outlen);
@@ -147,8 +147,8 @@ hmac_verify (gcry_mac_hd_t h, const unsigned char *buf, size_t buflen)
   unsigned int dlen;
   const unsigned char *digest;
 
   unsigned int dlen;
   const unsigned char *digest;
 
-  dlen = gcry_md_get_algo_dlen (h->u.hmac.md_algo);
-  digest = gcry_md_read (h->u.hmac.md_ctx, h->u.hmac.md_algo);
+  dlen = _gcry_md_get_algo_dlen (h->u.hmac.md_algo);
+  digest = _gcry_md_read (h->u.hmac.md_ctx, h->u.hmac.md_algo);
 
   if (buflen > dlen)
     return GPG_ERR_INV_LENGTH;
 
   if (buflen > dlen)
     return GPG_ERR_INV_LENGTH;
@@ -160,7 +160,7 @@ hmac_verify (gcry_mac_hd_t h, const unsigned char *buf, size_t buflen)
 static unsigned int
 hmac_get_maclen (int algo)
 {
 static unsigned int
 hmac_get_maclen (int algo)
 {
-  return gcry_md_get_algo_dlen (map_mac_algo_to_md (algo));
+  return _gcry_md_get_algo_dlen (map_mac_algo_to_md (algo));
 }
 
 
 }
 
 
index 5ac8729..71d5953 100644 (file)
@@ -140,7 +140,7 @@ spec_from_name (const char *name)
  * Map a string to the mac algo
  */
 int
  * Map a string to the mac algo
  */
 int
-gcry_mac_map_name (const char *string)
+_gcry_mac_map_name (const char *string)
 {
   gcry_mac_spec_t *spec;
 
 {
   gcry_mac_spec_t *spec;
 
@@ -163,7 +163,7 @@ gcry_mac_map_name (const char *string)
  * is valid.
  */
 const char *
  * is valid.
  */
 const char *
-gcry_mac_algo_name (int algorithm)
+_gcry_mac_algo_name (int algorithm)
 {
   gcry_mac_spec_t *spec;
 
 {
   gcry_mac_spec_t *spec;
 
@@ -310,87 +310,67 @@ mac_verify (gcry_mac_hd_t hd, const void *buf, size_t buflen)
 /* Create a MAC object for algorithm ALGO.  FLAGS may be
    given as an bitwise OR of the gcry_mac_flags values.
    H is guaranteed to be a valid handle or NULL on error.  */
 /* Create a MAC object for algorithm ALGO.  FLAGS may be
    given as an bitwise OR of the gcry_mac_flags values.
    H is guaranteed to be a valid handle or NULL on error.  */
-gcry_error_t
-gcry_mac_open (gcry_mac_hd_t * h, int algo, unsigned int flags,
-               gcry_ctx_t ctx)
+gpg_err_code_t
+_gcry_mac_open (gcry_mac_hd_t * h, int algo, unsigned int flags,
+                gcry_ctx_t ctx)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
   gcry_mac_hd_t hd = NULL;
 
   if ((flags & ~GCRY_MAC_FLAG_SECURE))
   gcry_mac_hd_t hd = NULL;
 
   if ((flags & ~GCRY_MAC_FLAG_SECURE))
-    err = GPG_ERR_INV_ARG;
+    rc = GPG_ERR_INV_ARG;
   else
   else
-    err = mac_open (&hd, algo, !!(flags & GCRY_MAC_FLAG_SECURE), ctx);
+    rc = mac_open (&hd, algo, !!(flags & GCRY_MAC_FLAG_SECURE), ctx);
 
 
-  *h = err ? NULL : hd;
-  return gpg_error (err);
+  *h = rc ? NULL : hd;
+  return rc;
 }
 
 
 void
 }
 
 
 void
-gcry_mac_close (gcry_mac_hd_t hd)
+_gcry_mac_close (gcry_mac_hd_t hd)
 {
   mac_close (hd);
 }
 
 
 {
   mac_close (hd);
 }
 
 
-gcry_error_t
-gcry_mac_setkey (gcry_mac_hd_t hd, const void *key, size_t keylen)
+gcry_err_code_t
+_gcry_mac_setkey (gcry_mac_hd_t hd, const void *key, size_t keylen)
 {
 {
-  gcry_error_t err;
-
-  err = mac_setkey (hd, key, keylen);
-
-  return gpg_error (err);
+  return mac_setkey (hd, key, keylen);
 }
 
 
 }
 
 
-gcry_error_t
-gcry_mac_setiv (gcry_mac_hd_t hd, const void *iv, size_t ivlen)
+gcry_err_code_t
+_gcry_mac_setiv (gcry_mac_hd_t hd, const void *iv, size_t ivlen)
 {
 {
-  gcry_error_t err;
-
-  err = mac_setiv (hd, iv, ivlen);
-
-  return gpg_error (err);
+  return mac_setiv (hd, iv, ivlen);
 }
 
 
 }
 
 
-gcry_error_t
-gcry_mac_write (gcry_mac_hd_t hd, const void *inbuf, size_t inlen)
+gcry_err_code_t
+_gcry_mac_write (gcry_mac_hd_t hd, const void *inbuf, size_t inlen)
 {
 {
-  gcry_err_code_t err;
-
-  err = mac_write (hd, inbuf, inlen);
-
-  return gpg_error (err);
+  return mac_write (hd, inbuf, inlen);
 }
 
 
 }
 
 
-gcry_error_t
-gcry_mac_read (gcry_mac_hd_t hd, void *outbuf, size_t * outlen)
+gcry_err_code_t
+_gcry_mac_read (gcry_mac_hd_t hd, void *outbuf, size_t * outlen)
 {
 {
-  gcry_error_t err;
-
-  err = mac_read (hd, outbuf, outlen);
-
-  return gpg_error (err);
+  return mac_read (hd, outbuf, outlen);
 }
 
 
 }
 
 
-gcry_error_t
-gcry_mac_verify (gcry_mac_hd_t hd, const void *buf, size_t buflen)
+gcry_err_code_t
+_gcry_mac_verify (gcry_mac_hd_t hd, const void *buf, size_t buflen)
 {
 {
-  gcry_err_code_t err;
-
-  err = mac_verify (hd, buf, buflen);
-
-  return gpg_error (err);
+  return mac_verify (hd, buf, buflen);
 }
 
 
 unsigned int
 }
 
 
 unsigned int
-gcry_mac_get_algo_maclen (int algo)
+_gcry_mac_get_algo_maclen (int algo)
 {
   gcry_mac_spec_t *spec;
 
 {
   gcry_mac_spec_t *spec;
 
@@ -403,7 +383,7 @@ gcry_mac_get_algo_maclen (int algo)
 
 
 unsigned int
 
 
 unsigned int
-gcry_mac_get_algo_keylen (int algo)
+_gcry_mac_get_algo_keylen (int algo)
 {
   gcry_mac_spec_t *spec;
 
 {
   gcry_mac_spec_t *spec;
 
@@ -415,10 +395,10 @@ gcry_mac_get_algo_keylen (int algo)
 }
 
 
 }
 
 
-gcry_error_t
-gcry_mac_ctl (gcry_mac_hd_t hd, int cmd, void *buffer, size_t buflen)
+gcry_err_code_t
+_gcry_mac_ctl (gcry_mac_hd_t hd, int cmd, void *buffer, size_t buflen)
 {
 {
-  gcry_err_code_t rc = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc;
 
   /* Currently not used.  */
   (void) hd;
 
   /* Currently not used.  */
   (void) hd;
@@ -433,7 +413,7 @@ gcry_mac_ctl (gcry_mac_hd_t hd, int cmd, void *buffer, size_t buflen)
     default:
       rc = GPG_ERR_INV_OP;
     }
     default:
       rc = GPG_ERR_INV_OP;
     }
-  return gcry_error (rc);
+  return rc;
 }
 
 
 }
 
 
@@ -449,37 +429,37 @@ gcry_mac_ctl (gcry_mac_hd_t hd, int cmd, void *buffer, size_t buflen)
    and thereby detecting whether a error occurred or not (i.e. while
    checking the block size)
  */
    and thereby detecting whether a error occurred or not (i.e. while
    checking the block size)
  */
-gcry_error_t
-gcry_mac_algo_info (int algo, int what, void *buffer, size_t * nbytes)
+gcry_err_code_t
+_gcry_mac_algo_info (int algo, int what, void *buffer, size_t * nbytes)
 {
 {
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
   unsigned int ui;
 
   switch (what)
     {
     case GCRYCTL_GET_KEYLEN:
       if (buffer || (!nbytes))
   unsigned int ui;
 
   switch (what)
     {
     case GCRYCTL_GET_KEYLEN:
       if (buffer || (!nbytes))
-        err = GPG_ERR_INV_ARG;
+        rc = GPG_ERR_INV_ARG;
       else
         {
       else
         {
-          ui = gcry_mac_get_algo_keylen (algo);
+          ui = _gcry_mac_get_algo_keylen (algo);
           if (ui > 0)
             *nbytes = (size_t) ui;
           else
             /* The only reason for an error is an invalid algo.  */
           if (ui > 0)
             *nbytes = (size_t) ui;
           else
             /* The only reason for an error is an invalid algo.  */
-            err = GPG_ERR_MAC_ALGO;
+            rc = GPG_ERR_MAC_ALGO;
         }
       break;
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
         }
       break;
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
-        err = GPG_ERR_INV_ARG;
+        rc = GPG_ERR_INV_ARG;
       else
       else
-        err = check_mac_algo (algo);
+        rc = check_mac_algo (algo);
       break;
 
     default:
       break;
 
     default:
-      err = GPG_ERR_INV_OP;
+      rc = GPG_ERR_INV_OP;
     }
 
     }
 
-  return gcry_error (err);
+  return rc;
 }
 }
index 65dadd1..4be8627 100644 (file)
@@ -211,7 +211,7 @@ search_oid (const char *oid, gcry_md_oid_spec_t *oid_spec)
  * Map a string to the digest algo
  */
 int
  * Map a string to the digest algo
  */
 int
-gcry_md_map_name (const char *string)
+_gcry_md_map_name (const char *string)
 {
   gcry_md_spec_t *spec;
 
 {
   gcry_md_spec_t *spec;
 
@@ -241,7 +241,7 @@ gcry_md_map_name (const char *string)
  * is valid.
  */
 const char *
  * is valid.
  */
 const char *
-gcry_md_algo_name (int algorithm)
+_gcry_md_algo_name (int algorithm)
 {
   gcry_md_spec_t *spec;
 
 {
   gcry_md_spec_t *spec;
 
@@ -366,22 +366,22 @@ md_open (gcry_md_hd_t *h, int algo, int secure, int hmac)
    given as 0 if the algorithms to be used are later set using
    gcry_md_enable. H is guaranteed to be a valid handle or NULL on
    error.  */
    given as 0 if the algorithms to be used are later set using
    gcry_md_enable. H is guaranteed to be a valid handle or NULL on
    error.  */
-gcry_error_t
-gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
+gcry_err_code_t
+_gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
   gcry_md_hd_t hd;
 
   if ((flags & ~(GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC)))
   gcry_md_hd_t hd;
 
   if ((flags & ~(GCRY_MD_FLAG_SECURE | GCRY_MD_FLAG_HMAC)))
-    err = GPG_ERR_INV_ARG;
+    rc = GPG_ERR_INV_ARG;
   else
     {
   else
     {
-      err = md_open (&hd, algo, (flags & GCRY_MD_FLAG_SECURE),
-                    (flags & GCRY_MD_FLAG_HMAC));
+      rc = md_open (&hd, algo, (flags & GCRY_MD_FLAG_SECURE),
+                    (flags & GCRY_MD_FLAG_HMAC));
     }
 
     }
 
-  *h = err? NULL : hd;
-  return gcry_error (err);
+  *h = rc? NULL : hd;
+  return rc;
 }
 
 
 }
 
 
@@ -447,10 +447,10 @@ md_enable (gcry_md_hd_t hd, int algorithm)
 }
 
 
 }
 
 
-gcry_error_t
-gcry_md_enable (gcry_md_hd_t hd, int algorithm)
+gcry_err_code_t
+_gcry_md_enable (gcry_md_hd_t hd, int algorithm)
 {
 {
-  return gcry_error (md_enable (hd, algorithm));
+  return md_enable (hd, algorithm);
 }
 
 
 }
 
 
@@ -538,15 +538,15 @@ md_copy (gcry_md_hd_t ahd, gcry_md_hd_t *b_hd)
 }
 
 
 }
 
 
-gcry_error_t
-gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
+gcry_err_code_t
+_gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
 
 
-  err = md_copy (hd, handle);
-  if (err)
+  rc = md_copy (hd, handle);
+  if (rc)
     *handle = NULL;
     *handle = NULL;
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -555,7 +555,7 @@ gcry_md_copy (gcry_md_hd_t *handle, gcry_md_hd_t hd)
  * instead of a md_close(); md_open().
  */
 void
  * instead of a md_close(); md_open().
  */
 void
-gcry_md_reset (gcry_md_hd_t a)
+_gcry_md_reset (gcry_md_hd_t a)
 {
   GcryDigestEntry *r;
 
 {
   GcryDigestEntry *r;
 
@@ -601,7 +601,7 @@ md_close (gcry_md_hd_t a)
 
 
 void
 
 
 void
-gcry_md_close (gcry_md_hd_t hd)
+_gcry_md_close (gcry_md_hd_t hd)
 {
   /* Note: We allow this even in fips non operational mode.  */
   md_close (hd);
 {
   /* Note: We allow this even in fips non operational mode.  */
   md_close (hd);
@@ -632,7 +632,7 @@ md_write (gcry_md_hd_t a, const void *inbuf, size_t inlen)
 
 
 void
 
 
 void
-gcry_md_write (gcry_md_hd_t hd, const void *inbuf, size_t inlen)
+_gcry_md_write (gcry_md_hd_t hd, const void *inbuf, size_t inlen)
 {
   md_write (hd, inbuf, inlen);
 }
 {
   md_write (hd, inbuf, inlen);
 }
@@ -693,7 +693,7 @@ prepare_macpads (gcry_md_hd_t hd, const unsigned char *key, size_t keylen)
       helpkey = gcry_malloc_secure (md_digest_length (algo));
       if (!helpkey)
         return gpg_err_code_from_errno (errno);
       helpkey = gcry_malloc_secure (md_digest_length (algo));
       if (!helpkey)
         return gpg_err_code_from_errno (errno);
-      gcry_md_hash_buffer (algo, helpkey, key, keylen);
+      _gcry_md_hash_buffer (algo, helpkey, key, keylen);
       key = helpkey;
       keylen = md_digest_length (algo);
       gcry_assert ( keylen <= hd->ctx->macpads_Bsize );
       key = helpkey;
       keylen = md_digest_length (algo);
       gcry_assert ( keylen <= hd->ctx->macpads_Bsize );
@@ -715,8 +715,8 @@ prepare_macpads (gcry_md_hd_t hd, const unsigned char *key, size_t keylen)
 }
 
 
 }
 
 
-gcry_error_t
-gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
+gcry_err_code_t
+_gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
 {
   gcry_err_code_t rc = 0;
 
 {
   gcry_err_code_t rc = 0;
 
@@ -736,12 +736,12 @@ gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
     default:
       rc = GPG_ERR_INV_OP;
     }
     default:
       rc = GPG_ERR_INV_OP;
     }
-  return gcry_error (rc);
+  return rc;
 }
 
 
 }
 
 
-gcry_error_t
-gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
+gcry_err_code_t
+_gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
 {
   gcry_err_code_t rc;
 
 {
   gcry_err_code_t rc;
 
@@ -750,11 +750,11 @@ gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
   else
     {
       rc = prepare_macpads (hd, key, keylen);
   else
     {
       rc = prepare_macpads (hd, key, keylen);
-      if (! rc)
-       gcry_md_reset (hd);
+      if (!rc)
+       _gcry_md_reset (hd);
     }
 
     }
 
-  return gcry_error (rc);
+  return rc;
 }
 
 
 }
 
 
@@ -762,7 +762,7 @@ gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
    file for the context HD.  IF suffix is NULL, the file is closed and
    debugging is stopped.  */
 void
    file for the context HD.  IF suffix is NULL, the file is closed and
    debugging is stopped.  */
 void
-gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
+_gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
 {
   if (suffix)
     md_start_debug (hd, suffix);
 {
   if (suffix)
     md_start_debug (hd, suffix);
@@ -806,12 +806,12 @@ md_read( gcry_md_hd_t a, int algo )
  * the hash.
  */
 byte *
  * the hash.
  */
 byte *
-gcry_md_read (gcry_md_hd_t hd, int algo)
+_gcry_md_read (gcry_md_hd_t hd, int algo)
 {
   /* This function is expected to always return a digest, thus we
      can't return an error which we actually should do in
      non-operational state.  */
 {
   /* This function is expected to always return a digest, thus we
      can't return an error which we actually should do in
      non-operational state.  */
-  gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
+  _gcry_md_ctl (hd, GCRYCTL_FINALIZE, NULL, 0);
   return md_read (hd, algo);
 }
 
   return md_read (hd, algo);
 }
 
@@ -820,7 +820,7 @@ gcry_md_read (gcry_md_hd_t hd, int algo)
  * Read out an intermediate digest.  Not yet functional.
  */
 gcry_err_code_t
  * Read out an intermediate digest.  Not yet functional.
  */
 gcry_err_code_t
-gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
+_gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
 {
   (void)hd;
   (void)algo;
 {
   (void)hd;
   (void)algo;
@@ -840,8 +840,8 @@ gcry_md_get (gcry_md_hd_t hd, int algo, byte *buffer, int buflen)
  * hash.  No error is returned, the function will abort on an invalid
  * algo.  DISABLED_ALGOS are ignored here.  */
 void
  * hash.  No error is returned, the function will abort on an invalid
  * algo.  DISABLED_ALGOS are ignored here.  */
 void
-gcry_md_hash_buffer (int algo, void *digest,
-                     const void *buffer, size_t length)
+_gcry_md_hash_buffer (int algo, void *digest,
+                      const void *buffer, size_t length)
 {
   if (algo == GCRY_MD_SHA1)
     _gcry_sha1_hash_buffer (digest, buffer, length);
 {
   if (algo == GCRY_MD_SHA1)
     _gcry_sha1_hash_buffer (digest, buffer, length);
@@ -892,8 +892,8 @@ gcry_md_hash_buffer (int algo, void *digest,
    DIGEST which must have been provided by the caller with an
    appropriate length.  */
 gpg_err_code_t
    DIGEST which must have been provided by the caller with an
    appropriate length.  */
 gpg_err_code_t
-gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
-                      const gcry_buffer_t *iov, int iovcnt)
+_gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
+                       const gcry_buffer_t *iov, int iovcnt)
 {
   int hmac;
 
 {
   int hmac;
 
@@ -932,9 +932,9 @@ gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
 
       if (hmac)
         {
 
       if (hmac)
         {
-          rc = gcry_err_code
-            (gcry_md_setkey (h, (const char*)iov[0].data + iov[0].off,
-                             iov[0].len));
+          rc = _gcry_md_setkey (h,
+                                (const char*)iov[0].data + iov[0].off,
+                                iov[0].len);
           if (rc)
             {
               md_close (h);
           if (rc)
             {
               md_close (h);
@@ -968,7 +968,7 @@ md_get_algo (gcry_md_hd_t a)
 
 
 int
 
 
 int
-gcry_md_get_algo (gcry_md_hd_t hd)
+_gcry_md_get_algo (gcry_md_hd_t hd)
 {
   return md_get_algo (hd);
 }
 {
   return md_get_algo (hd);
 }
@@ -992,7 +992,7 @@ md_digest_length (int algorithm)
  * This function will return 0 in case of errors.
  */
 unsigned int
  * This function will return 0 in case of errors.
  */
 unsigned int
-gcry_md_get_algo_dlen (int algorithm)
+_gcry_md_get_algo_dlen (int algorithm)
 {
   return md_digest_length (algorithm);
 }
 {
   return md_digest_length (algorithm);
 }
@@ -1040,25 +1040,25 @@ md_asn_oid (int algorithm, size_t *asnlen, size_t *mdlen)
  * and thereby detecting whether a error occurred or not (i.e. while checking
  * the block size)
  */
  * and thereby detecting whether a error occurred or not (i.e. while checking
  * the block size)
  */
-gcry_error_t
-gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
+gcry_err_code_t
+_gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
 {
 {
-  gcry_err_code_t err;
+  gcry_err_code_t rc;
 
   switch (what)
     {
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
 
   switch (what)
     {
     case GCRYCTL_TEST_ALGO:
       if (buffer || nbytes)
-       err = GPG_ERR_INV_ARG;
+       rc = GPG_ERR_INV_ARG;
       else
       else
-       err = check_digest_algo (algo);
+       rc = check_digest_algo (algo);
       break;
 
     case GCRYCTL_GET_ASNOID:
       /* We need to check that the algo is available because
          md_asn_oid would otherwise raise an assertion. */
       break;
 
     case GCRYCTL_GET_ASNOID:
       /* We need to check that the algo is available because
          md_asn_oid would otherwise raise an assertion. */
-      err = check_digest_algo (algo);
-      if (!err)
+      rc = check_digest_algo (algo);
+      if (!rc)
         {
           const char unsigned *asn;
           size_t asnlen;
         {
           const char unsigned *asn;
           size_t asnlen;
@@ -1074,25 +1074,25 @@ gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
           else
             {
               if (buffer)
           else
             {
               if (buffer)
-                err = GPG_ERR_TOO_SHORT;
+                rc = GPG_ERR_TOO_SHORT;
               else
               else
-                err = GPG_ERR_INV_ARG;
+                rc = GPG_ERR_INV_ARG;
             }
         }
       break;
 
     case GCRYCTL_SELFTEST:
       /* Helper function for the regression tests.  */
             }
         }
       break;
 
     case GCRYCTL_SELFTEST:
       /* Helper function for the regression tests.  */
-      err = gpg_err_code (_gcry_md_selftest (algo, nbytes? (int)*nbytes : 0,
+      rc = gpg_err_code (_gcry_md_selftest (algo, nbytes? (int)*nbytes : 0,
                                              NULL));
       break;
 
     default:
                                              NULL));
       break;
 
     default:
-      err = GPG_ERR_INV_OP;
+      rc = GPG_ERR_INV_OP;
       break;
   }
 
       break;
   }
 
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -1151,10 +1151,10 @@ md_stop_debug( gcry_md_hd_t md )
  *     Returns 1 if the algo is enabled for that handle.
  *     The algo must be passed as the address of an int.
  */
  *     Returns 1 if the algo is enabled for that handle.
  *     The algo must be passed as the address of an int.
  */
-gcry_error_t
-gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
+gcry_err_code_t
+_gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
 {
 {
-  gcry_err_code_t err = 0;
+  gcry_err_code_t rc = 0;
 
   switch (cmd)
     {
 
   switch (cmd)
     {
@@ -1168,7 +1168,7 @@ gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
        int algo;
 
        if ( !buffer || (nbytes && (*nbytes != sizeof (int))))
        int algo;
 
        if ( !buffer || (nbytes && (*nbytes != sizeof (int))))
-         err = GPG_ERR_INV_ARG;
+         rc = GPG_ERR_INV_ARG;
        else
          {
            algo = *(int*)buffer;
        else
          {
            algo = *(int*)buffer;
@@ -1186,10 +1186,10 @@ gcry_md_info (gcry_md_hd_t h, int cmd, void *buffer, size_t *nbytes)
       }
 
   default:
       }
 
   default:
-    err = GPG_ERR_INV_OP;
+    rc = GPG_ERR_INV_OP;
   }
 
   }
 
-  return gcry_error (err);
+  return rc;
 }
 
 
 }
 
 
@@ -1202,11 +1202,11 @@ _gcry_md_init (void)
 
 
 int
 
 
 int
-gcry_md_is_secure (gcry_md_hd_t a)
+_gcry_md_is_secure (gcry_md_hd_t a)
 {
   size_t value;
 
 {
   size_t value;
 
-  if (gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
+  if (_gcry_md_info (a, GCRYCTL_IS_SECURE, NULL, &value))
     value = 1; /* It seems to be better to assume secure memory on
                   error. */
   return value;
     value = 1; /* It seems to be better to assume secure memory on
                   error. */
   return value;
@@ -1214,12 +1214,12 @@ gcry_md_is_secure (gcry_md_hd_t a)
 
 
 int
 
 
 int
-gcry_md_is_enabled (gcry_md_hd_t a, int algo)
+_gcry_md_is_enabled (gcry_md_hd_t a, int algo)
 {
   size_t value;
 
   value = sizeof algo;
 {
   size_t value;
 
   value = sizeof algo;
-  if (gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
+  if (_gcry_md_info (a, GCRYCTL_IS_ALGO_ENABLED, &algo, &value))
     value = 0;
   return value;
 }
     value = 0;
   return value;
 }
index 94e8599..8694c31 100644 (file)
@@ -179,7 +179,7 @@ save_pool_prime (gcry_mpi_t prime, gcry_random_level_t randomlevel)
         {
           if (i >= n/3*2)
             {
         {
           if (i >= n/3*2)
             {
-              gcry_mpi_release (item2->prime);
+              _gcry_mpi_release (item2->prime);
               item2->prime = NULL;
               if (!item)
                 item = item2;
               item2->prime = NULL;
               if (!item)
                 item = item2;
@@ -192,7 +192,7 @@ save_pool_prime (gcry_mpi_t prime, gcry_random_level_t randomlevel)
       if (!item)
         {
           /* Out of memory.  Silently giving up. */
       if (!item)
         {
           /* Out of memory.  Silently giving up. */
-          gcry_mpi_release (prime);
+          _gcry_mpi_release (prime);
           return;
         }
       item->next = primepool;
           return;
         }
       item->next = primepool;
@@ -376,7 +376,7 @@ prime_generate_internal (int need_q_factor,
                pbits, req_qbits, qbits, fbits, n);
 
   /* Allocate an integer to old the new prime. */
                pbits, req_qbits, qbits, fbits, n);
 
   /* Allocate an integer to old the new prime. */
-  prime = gcry_mpi_new (pbits);
+  prime = mpi_new (pbits);
 
   /* Generate first prime factor.  */
   q = gen_prime (qbits, is_secret, randomlevel, NULL, NULL);
 
   /* Generate first prime factor.  */
   q = gen_prime (qbits, is_secret, randomlevel, NULL, NULL);
@@ -614,7 +614,7 @@ prime_generate_internal (int need_q_factor,
       if (all_factors)
         {
           i = 0;
       if (all_factors)
         {
           i = 0;
-          factors_new[i++] = gcry_mpi_set_ui (NULL, 2);
+          factors_new[i++] = mpi_set_ui (NULL, 2);
           factors_new[i++] = mpi_copy (q);
           if (need_q_factor)
             factors_new[i++] = mpi_copy (q_factor);
           factors_new[i++] = mpi_copy (q);
           if (need_q_factor)
             factors_new[i++] = mpi_copy (q_factor);
@@ -663,7 +663,7 @@ prime_generate_internal (int need_q_factor,
                   mpi_fdiv_q (tmp, pmin1, factors[i]);
                   /* No mpi_pow(), but it is okay to use this with mod
                      prime.  */
                   mpi_fdiv_q (tmp, pmin1, factors[i]);
                   /* No mpi_pow(), but it is okay to use this with mod
                      prime.  */
-                  gcry_mpi_powm (b, g, tmp, prime);
+                  mpi_powm (b, g, tmp, prime);
                   if (! mpi_cmp_ui (b, 1))
                     break;
                 }
                   if (! mpi_cmp_ui (b, 1))
                     break;
                 }
@@ -776,7 +776,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
   /* Make nbits fit into gcry_mpi_t implementation. */
   val_2  = mpi_alloc_set_ui( 2 );
   val_3 = mpi_alloc_set_ui( 3);
   /* Make nbits fit into gcry_mpi_t implementation. */
   val_2  = mpi_alloc_set_ui( 2 );
   val_3 = mpi_alloc_set_ui( 3);
-  prime  = secret? gcry_mpi_snew ( nbits ): gcry_mpi_new ( nbits );
+  prime  = secret? mpi_snew (nbits): mpi_new (nbits);
   result = mpi_alloc_like( prime );
   pminus1= mpi_alloc_like( prime );
   ptest  = mpi_alloc_like( prime );
   result = mpi_alloc_like( prime );
   pminus1= mpi_alloc_like( prime );
   ptest  = mpi_alloc_like( prime );
@@ -786,7 +786,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
       int dotcount=0;
 
       /* generate a random number */
       int dotcount=0;
 
       /* generate a random number */
-      gcry_mpi_randomize( prime, nbits, randomlevel );
+      _gcry_mpi_randomize( prime, nbits, randomlevel );
 
       /* Set high order bit to 1, set low order bit to 1.  If we are
          generating a secret prime we are most probably doing that
 
       /* Set high order bit to 1, set low order bit to 1.  If we are
          generating a secret prime we are most probably doing that
@@ -821,7 +821,7 @@ gen_prime (unsigned int nbits, int secret, int randomlevel,
           /* Do a fast Fermat test now. */
           count2++;
           mpi_sub_ui( pminus1, ptest, 1);
           /* Do a fast Fermat test now. */
           count2++;
           mpi_sub_ui( pminus1, ptest, 1);
-          gcry_mpi_powm( result, val_2, pminus1, ptest );
+          mpi_powm( result, val_2, pminus1, ptest );
           if ( !mpi_cmp_ui( result, 1 ) )
             {
               /* Not composite, perform stronger tests */
           if ( !mpi_cmp_ui( result, 1 ) )
             {
               /* Not composite, perform stronger tests */
@@ -887,7 +887,7 @@ check_prime( gcry_mpi_t prime, gcry_mpi_t val_2, int rm_rounds,
     gcry_mpi_t result = mpi_alloc_like( prime );
     gcry_mpi_t pminus1 = mpi_alloc_like( prime );
     mpi_sub_ui( pminus1, prime, 1);
     gcry_mpi_t result = mpi_alloc_like( prime );
     gcry_mpi_t pminus1 = mpi_alloc_like( prime );
     mpi_sub_ui( pminus1, prime, 1);
-    gcry_mpi_powm( result, val_2, pminus1, prime );
+    mpi_powm( result, val_2, pminus1, prime );
     mpi_free( pminus1 );
     if ( mpi_cmp_ui( result, 1 ) )
       {
     mpi_free( pminus1 );
     if ( mpi_cmp_ui( result, 1 ) )
       {
@@ -949,7 +949,7 @@ is_prime (gcry_mpi_t n, int steps, unsigned int *count)
         }
       else
         {
         }
       else
         {
-          gcry_mpi_randomize( x, nbits, GCRY_WEAK_RANDOM );
+          _gcry_mpi_randomize( x, nbits, GCRY_WEAK_RANDOM );
 
           /* Make sure that the number is smaller than the prime and
              keep the randomness of the high bit. */
 
           /* Make sure that the number is smaller than the prime and
              keep the randomness of the high bit. */
@@ -964,12 +964,12 @@ is_prime (gcry_mpi_t n, int steps, unsigned int *count)
             }
           gcry_assert (mpi_cmp (x, nminus1) < 0 && mpi_cmp_ui (x, 1) > 0);
        }
             }
           gcry_assert (mpi_cmp (x, nminus1) < 0 && mpi_cmp_ui (x, 1) > 0);
        }
-      gcry_mpi_powm ( y, x, q, n);
+      mpi_powm ( y, x, q, n);
       if ( mpi_cmp_ui(y, 1) && mpi_cmp( y, nminus1 ) )
         {
           for ( j=1; j < k && mpi_cmp( y, nminus1 ); j++ )
             {
       if ( mpi_cmp_ui(y, 1) && mpi_cmp( y, nminus1 ) )
         {
           for ( j=1; j < k && mpi_cmp( y, nminus1 ); j++ )
             {
-              gcry_mpi_powm(y, y, a2, n);
+              mpi_powm(y, y, a2, n);
               if( !mpi_cmp_ui( y, 1 ) )
                 goto leave; /* Not a prime. */
             }
               if( !mpi_cmp_ui( y, 1 ) )
                 goto leave; /* Not a prime. */
             }
@@ -1121,67 +1121,66 @@ m_out_of_n ( char *array, int m, int n )
    non-zero, allocate a new, NULL-terminated array holding the prime
    factors and store it in FACTORS.  FLAGS might be used to influence
    the prime number generation process.  */
    non-zero, allocate a new, NULL-terminated array holding the prime
    factors and store it in FACTORS.  FLAGS might be used to influence
    the prime number generation process.  */
-gcry_error_t
-gcry_prime_generate (gcry_mpi_t *prime, unsigned int prime_bits,
-                    unsigned int factor_bits, gcry_mpi_t **factors,
-                    gcry_prime_check_func_t cb_func, void *cb_arg,
-                    gcry_random_level_t random_level,
-                    unsigned int flags)
+gcry_err_code_t
+_gcry_prime_generate (gcry_mpi_t *prime, unsigned int prime_bits,
+                      unsigned int factor_bits, gcry_mpi_t **factors,
+                      gcry_prime_check_func_t cb_func, void *cb_arg,
+                      gcry_random_level_t random_level,
+                      unsigned int flags)
 {
 {
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
   gcry_mpi_t *factors_generated = NULL;
   gcry_mpi_t prime_generated = NULL;
   unsigned int mode = 0;
 
   if (!prime)
   gcry_mpi_t *factors_generated = NULL;
   gcry_mpi_t prime_generated = NULL;
   unsigned int mode = 0;
 
   if (!prime)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return GPG_ERR_INV_ARG;
   *prime = NULL;
 
   if (flags & GCRY_PRIME_FLAG_SPECIAL_FACTOR)
     mode = 1;
 
   /* Generate.  */
   *prime = NULL;
 
   if (flags & GCRY_PRIME_FLAG_SPECIAL_FACTOR)
     mode = 1;
 
   /* Generate.  */
-  err = prime_generate_internal ((mode==1), &prime_generated, prime_bits,
-                                factor_bits, NULL,
-                                 factors? &factors_generated : NULL,
-                                random_level, flags, 1,
-                                 cb_func, cb_arg);
+  rc = prime_generate_internal ((mode==1), &prime_generated, prime_bits,
+                                factor_bits, NULL,
+                                factors? &factors_generated : NULL,
+                                random_level, flags, 1,
+                                cb_func, cb_arg);
 
 
-  if (! err)
-    if (cb_func)
-      {
-       /* Additional check. */
-       if ( !cb_func (cb_arg, GCRY_PRIME_CHECK_AT_FINISH, prime_generated))
-         {
-           /* Failed, deallocate resources.  */
-           unsigned int i;
+  if (!rc && cb_func)
+    {
+      /* Additional check. */
+      if ( !cb_func (cb_arg, GCRY_PRIME_CHECK_AT_FINISH, prime_generated))
+        {
+          /* Failed, deallocate resources.  */
+          unsigned int i;
 
 
-           mpi_free (prime_generated);
-            if (factors)
-              {
-                for (i = 0; factors_generated[i]; i++)
-                  mpi_free (factors_generated[i]);
-                gcry_free (factors_generated);
-              }
-           err = GPG_ERR_GENERAL;
-         }
-      }
+          mpi_free (prime_generated);
+          if (factors)
+            {
+              for (i = 0; factors_generated[i]; i++)
+                mpi_free (factors_generated[i]);
+              gcry_free (factors_generated);
+            }
+          rc = GPG_ERR_GENERAL;
+        }
+    }
 
 
-  if (! err)
+  if (!rc)
     {
       if (factors)
         *factors = factors_generated;
       *prime = prime_generated;
     }
 
     {
       if (factors)
         *factors = factors_generated;
       *prime = prime_generated;
     }
 
-  return gcry_error (err);
+  return rc;
 }
 
 /* Check whether the number X is prime.  */
 }
 
 /* Check whether the number X is prime.  */
-gcry_error_t
-gcry_prime_check (gcry_mpi_t x, unsigned int flags)
+gcry_err_code_t
+_gcry_prime_check (gcry_mpi_t x, unsigned int flags)
 {
 {
-  gcry_err_code_t err = GPG_ERR_NO_ERROR;
+  gcry_err_code_t rc = 0;
   gcry_mpi_t val_2 = mpi_alloc_set_ui (2); /* Used by the Fermat test. */
 
   (void)flags;
   gcry_mpi_t val_2 = mpi_alloc_set_ui (2); /* Used by the Fermat test. */
 
   (void)flags;
@@ -1189,37 +1188,37 @@ gcry_prime_check (gcry_mpi_t x, unsigned int flags)
   /* We use 64 rounds because the prime we are going to test is not
      guaranteed to be a random one. */
   if (! check_prime (x, val_2, 64, NULL, NULL))
   /* We use 64 rounds because the prime we are going to test is not
      guaranteed to be a random one. */
   if (! check_prime (x, val_2, 64, NULL, NULL))
-    err = GPG_ERR_NO_PRIME;
+    rc = GPG_ERR_NO_PRIME;
 
   mpi_free (val_2);
 
 
   mpi_free (val_2);
 
-  return gcry_error (err);
+  return rc;
 }
 
 /* Find a generator for PRIME where the factorization of (prime-1) is
    in the NULL terminated array FACTORS. Return the generator as a
    newly allocated MPI in R_G.  If START_G is not NULL, use this as s
    atart for the search. Returns 0 on success.*/
 }
 
 /* Find a generator for PRIME where the factorization of (prime-1) is
    in the NULL terminated array FACTORS. Return the generator as a
    newly allocated MPI in R_G.  If START_G is not NULL, use this as s
    atart for the search. Returns 0 on success.*/
-gcry_error_t
-gcry_prime_group_generator (gcry_mpi_t *r_g,
-                            gcry_mpi_t prime, gcry_mpi_t *factors,
-                            gcry_mpi_t start_g)
+gcry_err_code_t
+_gcry_prime_group_generator (gcry_mpi_t *r_g,
+                             gcry_mpi_t prime, gcry_mpi_t *factors,
+                             gcry_mpi_t start_g)
 {
 {
-  gcry_mpi_t tmp = gcry_mpi_new (0);
-  gcry_mpi_t b = gcry_mpi_new (0);
-  gcry_mpi_t pmin1 = gcry_mpi_new (0);
-  gcry_mpi_t g = start_g? gcry_mpi_copy (start_g) : gcry_mpi_set_ui (NULL, 3);
+  gcry_mpi_t tmp   = mpi_new (0);
+  gcry_mpi_t b     = mpi_new (0);
+  gcry_mpi_t pmin1 = mpi_new (0);
+  gcry_mpi_t g = start_g? mpi_copy (start_g) : mpi_set_ui (NULL, 3);
   int first = 1;
   int i, n;
 
   if (!factors || !r_g || !prime)
   int first = 1;
   int i, n;
 
   if (!factors || !r_g || !prime)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return GPG_ERR_INV_ARG;
   *r_g = NULL;
 
   for (n=0; factors[n]; n++)
     ;
   if (n < 2)
   *r_g = NULL;
 
   for (n=0; factors[n]; n++)
     ;
   if (n < 2)
-    return gpg_error (GPG_ERR_INV_ARG);
+    return GPG_ERR_INV_ARG;
 
   /* Extra sanity check - usually disabled. */
 /*   mpi_set (tmp, factors[0]); */
 
   /* Extra sanity check - usually disabled. */
 /*   mpi_set (tmp, factors[0]); */
@@ -1229,13 +1228,13 @@ gcry_prime_group_generator (gcry_mpi_t *r_g,
 /*   if (mpi_cmp (prime, tmp)) */
 /*     return gpg_error (GPG_ERR_INV_ARG); */
 
 /*   if (mpi_cmp (prime, tmp)) */
 /*     return gpg_error (GPG_ERR_INV_ARG); */
 
-  gcry_mpi_sub_ui (pmin1, prime, 1);
+  mpi_sub_ui (pmin1, prime, 1);
   do
     {
       if (first)
         first = 0;
       else
   do
     {
       if (first)
         first = 0;
       else
-        gcry_mpi_add_ui (g, g, 1);
+        mpi_add_ui (g, g, 1);
 
       if (DBG_CIPHER)
         log_printmpi ("checking g", g);
 
       if (DBG_CIPHER)
         log_printmpi ("checking g", g);
@@ -1245,7 +1244,7 @@ gcry_prime_group_generator (gcry_mpi_t *r_g,
       for (i = 0; i < n; i++)
         {
           mpi_fdiv_q (tmp, pmin1, factors[i]);
       for (i = 0; i < n; i++)
         {
           mpi_fdiv_q (tmp, pmin1, factors[i]);
-          gcry_mpi_powm (b, g, tmp, prime);
+          mpi_powm (b, g, tmp, prime);
           if (! mpi_cmp_ui (b, 1))
             break;
         }
           if (! mpi_cmp_ui (b, 1))
             break;
         }
@@ -1254,9 +1253,9 @@ gcry_prime_group_generator (gcry_mpi_t *r_g,
     }
   while (i < n);
 
     }
   while (i < n);
 
-  gcry_mpi_release (tmp);
-  gcry_mpi_release (b);
-  gcry_mpi_release (pmin1);
+  _gcry_mpi_release (tmp);
+  _gcry_mpi_release (b);
+  _gcry_mpi_release (pmin1);
   *r_g = g;
 
   return 0;
   *r_g = g;
 
   return 0;
@@ -1264,7 +1263,7 @@ gcry_prime_group_generator (gcry_mpi_t *r_g,
 
 /* Convenience function to release the factors array. */
 void
 
 /* Convenience function to release the factors array. */
 void
-gcry_prime_release_factors (gcry_mpi_t *factors)
+_gcry_prime_release_factors (gcry_mpi_t *factors)
 {
   if (factors)
     {
 {
   if (factors)
     {
@@ -1285,7 +1284,7 @@ find_x931_prime (const gcry_mpi_t pfirst)
   gcry_mpi_t val_2 = mpi_alloc_set_ui (2);
   gcry_mpi_t prime;
 
   gcry_mpi_t val_2 = mpi_alloc_set_ui (2);
   gcry_mpi_t prime;
 
-  prime = gcry_mpi_copy (pfirst);
+  prime = mpi_copy (pfirst);
   /* If P is even add 1.  */
   mpi_set_bit (prime, 0);
 
   /* If P is even add 1.  */
   mpi_set_bit (prime, 0);
 
@@ -1389,7 +1388,7 @@ _gcry_derive_x931_prime (const gcry_mpi_t xp,
     mpi_sub_ui (yp0, yp0, 1);   /* Ditto.  */
     for (;;)
       {
     mpi_sub_ui (yp0, yp0, 1);   /* Ditto.  */
     for (;;)
       {
-        gcdres = gcry_mpi_gcd (gcdtmp, e, yp0);
+        gcdres = mpi_gcd (gcdtmp, e, yp0);
         mpi_add_ui (yp0, yp0, 1);
         if (!gcdres)
           progress ('/');  /* gcd (e, yp0-1) != 1  */
         mpi_add_ui (yp0, yp0, 1);
         if (!gcdres)
           progress ('/');  /* gcd (e, yp0-1) != 1  */
@@ -1468,8 +1467,8 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
   val_2   = mpi_alloc_set_ui (2);
   value_n = (pbits - 1) / qbits;
   value_b = (pbits - 1) - value_n * qbits;
   val_2   = mpi_alloc_set_ui (2);
   value_n = (pbits - 1) / qbits;
   value_b = (pbits - 1) - value_n * qbits;
-  value_w = gcry_mpi_new (pbits);
-  value_x = gcry_mpi_new (pbits);
+  value_w = mpi_new (pbits);
+  value_x = mpi_new (pbits);
 
  restart:
   /* Generate Q.  */
 
  restart:
   /* Generate Q.  */
@@ -1479,7 +1478,7 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
       if (!seed)
         {
           seedlen = sizeof seed_help_buffer;
       if (!seed)
         {
           seedlen = sizeof seed_help_buffer;
-          gcry_create_nonce (seed_help_buffer, seedlen);
+          _gcry_create_nonce (seed_help_buffer, seedlen);
           seed = seed_help_buffer;
         }
 
           seed = seed_help_buffer;
         }
 
@@ -1491,15 +1490,15 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
           if (seed_plus[i])
             break;
         }
           if (seed_plus[i])
             break;
         }
-      gcry_md_hash_buffer (GCRY_MD_SHA1, value_u, seed, seedlen);
-      gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
+      _gcry_md_hash_buffer (GCRY_MD_SHA1, value_u, seed, seedlen);
+      _gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
       for (i=0; i < sizeof value_u; i++)
         value_u[i] ^= digest[i];
 
       /* Step 3:  Form q from U  */
       for (i=0; i < sizeof value_u; i++)
         value_u[i] ^= digest[i];
 
       /* Step 3:  Form q from U  */
-      gcry_mpi_release (prime_q); prime_q = NULL;
-      ec = gpg_err_code (gcry_mpi_scan (&prime_q, GCRYMPI_FMT_USG,
-                                        value_u, sizeof value_u, NULL));
+      _gcry_mpi_release (prime_q); prime_q = NULL;
+      ec = _gcry_mpi_scan (&prime_q, GCRYMPI_FMT_USG,
+                           value_u, sizeof value_u, NULL);
       if (ec)
         goto leave;
       mpi_set_highbit (prime_q, qbits-1 );
       if (ec)
         goto leave;
       mpi_set_highbit (prime_q, qbits-1 );
@@ -1518,7 +1517,7 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
   counter = 0;
 
   /* Generate P. */
   counter = 0;
 
   /* Generate P. */
-  prime_p = gcry_mpi_new (pbits);
+  prime_p = mpi_new (pbits);
   for (;;)
     {
       /* Step 7: For k = 0,...n let
   for (;;)
     {
       /* Step 7: For k = 0,...n let
@@ -1544,11 +1543,11 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
               if (seed_plus[i])
                 break;
             }
               if (seed_plus[i])
                 break;
             }
-          gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
+          _gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
 
 
-          gcry_mpi_release (tmpval); tmpval = NULL;
-          ec = gpg_err_code (gcry_mpi_scan (&tmpval, GCRYMPI_FMT_USG,
-                                            digest, sizeof digest, NULL));
+          _gcry_mpi_release (tmpval); tmpval = NULL;
+          ec = _gcry_mpi_scan (&tmpval, GCRYMPI_FMT_USG,
+                               digest, sizeof digest, NULL);
           if (ec)
             goto leave;
           if (value_k == value_n)
           if (ec)
             goto leave;
           if (value_k == value_n)
@@ -1610,13 +1609,13 @@ _gcry_generate_fips186_2_prime (unsigned int pbits, unsigned int qbits,
 
 
  leave:
 
 
  leave:
-  gcry_mpi_release (tmpval);
-  gcry_mpi_release (value_x);
-  gcry_mpi_release (value_w);
-  gcry_mpi_release (prime_p);
-  gcry_mpi_release (prime_q);
+  _gcry_mpi_release (tmpval);
+  _gcry_mpi_release (value_x);
+  _gcry_mpi_release (value_w);
+  _gcry_mpi_release (prime_p);
+  _gcry_mpi_release (prime_q);
   gcry_free (seed_plus);
   gcry_free (seed_plus);
-  gcry_mpi_release (val_2);
+  _gcry_mpi_release (val_2);
   return ec;
 }
 
   return ec;
 }
 
@@ -1681,11 +1680,11 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
     return GPG_ERR_INV_KEYLEN;
 
   /* Also check that the hash algorithm is available.  */
     return GPG_ERR_INV_KEYLEN;
 
   /* Also check that the hash algorithm is available.  */
-  ec = gpg_err_code (gcry_md_test_algo (hashalgo));
+  ec = _gcry_md_test_algo (hashalgo);
   if (ec)
     return ec;
   gcry_assert (qbits/8 <= sizeof digest);
   if (ec)
     return ec;
   gcry_assert (qbits/8 <= sizeof digest);
-  gcry_assert (gcry_md_get_algo_dlen (hashalgo) == qbits/8);
+  gcry_assert (_gcry_md_get_algo_dlen (hashalgo) == qbits/8);
 
 
   /* Step 2:  Check seedlen.  */
 
 
   /* Step 2:  Check seedlen.  */
@@ -1704,8 +1703,8 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
       goto leave;
     }
   val_2   = mpi_alloc_set_ui (2);
       goto leave;
     }
   val_2   = mpi_alloc_set_ui (2);
-  value_w = gcry_mpi_new (pbits);
-  value_x = gcry_mpi_new (pbits);
+  value_w = mpi_new (pbits);
+  value_x = mpi_new (pbits);
 
   /* Step 3: n = \lceil L / outlen \rceil - 1  */
   value_n = (pbits + qbits - 1) / qbits - 1;
 
   /* Step 3: n = \lceil L / outlen \rceil - 1  */
   value_n = (pbits + qbits - 1) / qbits - 1;
@@ -1721,12 +1720,12 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
         {
           seedlen = qbits/8;
           gcry_assert (seedlen <= sizeof seed_help_buffer);
         {
           seedlen = qbits/8;
           gcry_assert (seedlen <= sizeof seed_help_buffer);
-          gcry_create_nonce (seed_help_buffer, seedlen);
+          _gcry_create_nonce (seed_help_buffer, seedlen);
           seed = seed_help_buffer;
         }
 
       /* Step 6:  U = hash(seed)  */
           seed = seed_help_buffer;
         }
 
       /* Step 6:  U = hash(seed)  */
-      gcry_md_hash_buffer (hashalgo, value_u, seed, seedlen);
+      _gcry_md_hash_buffer (hashalgo, value_u, seed, seedlen);
 
       /* Step 7:  q = 2^{N-1} + U + 1 - (U mod 2)  */
       if ( !(value_u[qbits/8-1] & 0x01) )
 
       /* Step 7:  q = 2^{N-1} + U + 1 - (U mod 2)  */
       if ( !(value_u[qbits/8-1] & 0x01) )
@@ -1738,9 +1737,9 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
                 break;
             }
         }
                 break;
             }
         }
-      gcry_mpi_release (prime_q); prime_q = NULL;
-      ec = gpg_err_code (gcry_mpi_scan (&prime_q, GCRYMPI_FMT_USG,
-                                        value_u, sizeof value_u, NULL));
+      _gcry_mpi_release (prime_q); prime_q = NULL;
+      ec = _gcry_mpi_scan (&prime_q, GCRYMPI_FMT_USG,
+                           value_u, sizeof value_u, NULL);
       if (ec)
         goto leave;
       mpi_set_highbit (prime_q, qbits-1 );
       if (ec)
         goto leave;
       mpi_set_highbit (prime_q, qbits-1 );
@@ -1761,7 +1760,7 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
   counter = 0;
 
   /* Generate P. */
   counter = 0;
 
   /* Generate P. */
-  prime_p = gcry_mpi_new (pbits);
+  prime_p = mpi_new (pbits);
   for (;;)
     {
       /* Step 11.1: For j = 0,...n let
   for (;;)
     {
       /* Step 11.1: For j = 0,...n let
@@ -1785,11 +1784,11 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
               if (seed_plus[i])
                 break;
             }
               if (seed_plus[i])
                 break;
             }
-          gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
+          _gcry_md_hash_buffer (GCRY_MD_SHA1, digest, seed_plus, seedlen);
 
 
-          gcry_mpi_release (tmpval); tmpval = NULL;
-          ec = gpg_err_code (gcry_mpi_scan (&tmpval, GCRYMPI_FMT_USG,
-                                            digest, sizeof digest, NULL));
+          _gcry_mpi_release (tmpval); tmpval = NULL;
+          ec = _gcry_mpi_scan (&tmpval, GCRYMPI_FMT_USG,
+                               digest, sizeof digest, NULL);
           if (ec)
             goto leave;
           if (value_j == value_n)
           if (ec)
             goto leave;
           if (value_j == value_n)
@@ -1853,12 +1852,12 @@ _gcry_generate_fips186_3_prime (unsigned int pbits, unsigned int qbits,
     *r_hashalgo = hashalgo;
 
  leave:
     *r_hashalgo = hashalgo;
 
  leave:
-  gcry_mpi_release (tmpval);
-  gcry_mpi_release (value_x);
-  gcry_mpi_release (value_w);
-  gcry_mpi_release (prime_p);
-  gcry_mpi_release (prime_q);
+  _gcry_mpi_release (tmpval);
+  _gcry_mpi_release (value_x);
+  _gcry_mpi_release (value_w);
+  _gcry_mpi_release (prime_p);
+  _gcry_mpi_release (prime_q);
   gcry_free (seed_plus);
   gcry_free (seed_plus);
-  gcry_mpi_release (val_2);
+  _gcry_mpi_release (val_2);
   return ec;
 }
   return ec;
 }
index 3e0b5ef..7f3fd82 100644 (file)
@@ -62,9 +62,9 @@ _gcry_pk_util_parse_flaglist (gcry_sexp_t list,
   int flags = 0;
   int igninvflag = 0;
 
   int flags = 0;
   int igninvflag = 0;
 
-  for (i=list?gcry_sexp_length (list)-1:0; i > 0; i--)
+  for (i = list ? sexp_length (list)-1 : 0; i > 0; i--)
     {
     {
-      s = gcry_sexp_nth_data (list, i, &n);
+      s = sexp_nth_data (list, i, &n);
       if (!s)
         continue; /* Not a data element. */
 
       if (!s)
         continue; /* Not a data element. */
 
@@ -225,7 +225,7 @@ get_hash_algo (const char *s, size_t n)
        {
          memcpy (tmpname, s, n);
          tmpname[n] = 0;
        {
          memcpy (tmpname, s, n);
          tmpname[n] = 0;
-         algo = gcry_md_map_name (tmpname);
+         algo = _gcry_md_map_name (tmpname);
          gcry_free (tmpname);
        }
     }
          gcry_free (tmpname);
        }
     }
@@ -259,21 +259,21 @@ _gcry_pk_util_get_nbits (gcry_sexp_t list, unsigned int *r_nbits)
 
   *r_nbits = 0;
 
 
   *r_nbits = 0;
 
-  list = gcry_sexp_find_token (list, "nbits", 0);
+  list = sexp_find_token (list, "nbits", 0);
   if (!list)
     return 0; /* No NBITS found.  */
 
   if (!list)
     return 0; /* No NBITS found.  */
 
-  s = gcry_sexp_nth_data (list, 1, &n);
+  s = sexp_nth_data (list, 1, &n);
   if (!s || n >= DIM (buf) - 1 )
     {
       /* NBITS given without a cdr.  */
   if (!s || n >= DIM (buf) - 1 )
     {
       /* NBITS given without a cdr.  */
-      gcry_sexp_release (list);
+      sexp_release (list);
       return GPG_ERR_INV_OBJ;
     }
   memcpy (buf, s, n);
   buf[n] = 0;
   *r_nbits = (unsigned int)strtoul (buf, NULL, 0);
       return GPG_ERR_INV_OBJ;
     }
   memcpy (buf, s, n);
   buf[n] = 0;
   *r_nbits = (unsigned int)strtoul (buf, NULL, 0);
-  gcry_sexp_release (list);
+  sexp_release (list);
   return 0;
 }
 
   return 0;
 }
 
@@ -306,24 +306,24 @@ _gcry_pk_util_get_rsa_use_e (gcry_sexp_t list, unsigned long *r_e)
 
   *r_e = 0;
 
 
   *r_e = 0;
 
-  list = gcry_sexp_find_token (list, "rsa-use-e", 0);
+  list = sexp_find_token (list, "rsa-use-e", 0);
   if (!list)
     {
       *r_e = 65537; /* Not given, use the value generated by old versions. */
       return 0;
     }
 
   if (!list)
     {
       *r_e = 65537; /* Not given, use the value generated by old versions. */
       return 0;
     }
 
-  s = gcry_sexp_nth_data (list, 1, &n);
+  s = sexp_nth_data (list, 1, &n);
   if (!s || n >= DIM (buf) - 1 )
     {
       /* No value or value too large.  */
   if (!s || n >= DIM (buf) - 1 )
     {
       /* No value or value too large.  */
-      gcry_sexp_release (list);
+      sexp_release (list);
       return GPG_ERR_INV_OBJ;
     }
   memcpy (buf, s, n);
   buf[n] = 0;
   *r_e = strtoul (buf, NULL, 0);
       return GPG_ERR_INV_OBJ;
     }
   memcpy (buf, s, n);
   buf[n] = 0;
   *r_e = strtoul (buf, NULL, 0);
-  gcry_sexp_release (list);
+  sexp_release (list);
   return 0;
 }
 
   return 0;
 }
 
@@ -350,20 +350,20 @@ _gcry_pk_util_preparse_sigval (gcry_sexp_t s_sig, const char **algo_names,
     *r_eccflags = 0;
 
   /* Extract the signature value.  */
     *r_eccflags = 0;
 
   /* Extract the signature value.  */
-  l1 = gcry_sexp_find_token (s_sig, "sig-val", 0);
+  l1 = sexp_find_token (s_sig, "sig-val", 0);
   if (!l1)
     {
       rc = GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
       goto leave;
     }
 
   if (!l1)
     {
       rc = GPG_ERR_INV_OBJ; /* Does not contain a signature value object.  */
       goto leave;
     }
 
-  l2 = gcry_sexp_nth (l1, 1);
+  l2 = sexp_nth (l1, 1);
   if (!l2)
     {
       rc = GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
       goto leave;
     }
   if (!l2)
     {
       rc = GPG_ERR_NO_OBJ;   /* No cadr for the sig object.  */
       goto leave;
     }
-  name = _gcry_sexp_nth_string (l2, 0);
+  name = sexp_nth_string (l2, 0);
   if (!name)
     {
       rc = GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
   if (!name)
     {
       rc = GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
@@ -374,15 +374,15 @@ _gcry_pk_util_preparse_sigval (gcry_sexp_t s_sig, const char **algo_names,
       /* Skip a "flags" parameter and look again for the algorithm
         name.  This is not used but here just for the sake of
         consistent S-expressions we need to handle it. */
       /* Skip a "flags" parameter and look again for the algorithm
         name.  This is not used but here just for the sake of
         consistent S-expressions we need to handle it. */
-      gcry_sexp_release (l2);
-      l2 = gcry_sexp_nth (l1, 2);
+      sexp_release (l2);
+      l2 = sexp_nth (l1, 2);
       if (!l2)
        {
          rc = GPG_ERR_INV_OBJ;
           goto leave;
        }
       gcry_free (name);
       if (!l2)
        {
          rc = GPG_ERR_INV_OBJ;
           goto leave;
        }
       gcry_free (name);
-      name = _gcry_sexp_nth_string (l2, 0);
+      name = sexp_nth_string (l2, 0);
       if (!name)
         {
           rc = GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
       if (!name)
         {
           rc = GPG_ERR_INV_OBJ;  /* Invalid structure of object.  */
@@ -412,8 +412,8 @@ _gcry_pk_util_preparse_sigval (gcry_sexp_t s_sig, const char **algo_names,
 
  leave:
   gcry_free (name);
 
  leave:
   gcry_free (name);
-  gcry_sexp_release (l2);
-  gcry_sexp_release (l1);
+  sexp_release (l2);
+  sexp_release (l1);
   return rc;
 }
 
   return rc;
 }
 
@@ -453,14 +453,14 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
   *r_parms = NULL;
 
   /* Check that the first element is valid.  */
   *r_parms = NULL;
 
   /* Check that the first element is valid.  */
-  l1 = gcry_sexp_find_token (sexp, "enc-val" , 0);
+  l1 = sexp_find_token (sexp, "enc-val" , 0);
   if (!l1)
     {
       rc = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
       goto leave;
     }
 
   if (!l1)
     {
       rc = GPG_ERR_INV_OBJ; /* Does not contain an encrypted value object.  */
       goto leave;
     }
 
-  l2 = gcry_sexp_nth (l1, 1);
+  l2 = sexp_nth (l1, 1);
   if (!l2)
     {
       rc = GPG_ERR_NO_OBJ;  /* No cadr for the data object.  */
   if (!l2)
     {
       rc = GPG_ERR_NO_OBJ;  /* No cadr for the data object.  */
@@ -468,7 +468,7 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
     }
 
   /* Extract identifier of sublist.  */
     }
 
   /* Extract identifier of sublist.  */
-  name = _gcry_sexp_nth_string (l2, 0);
+  name = sexp_nth_string (l2, 0);
   if (!name)
     {
       rc = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
   if (!name)
     {
       rc = GPG_ERR_INV_OBJ; /* Invalid structure of object.  */
@@ -493,11 +493,11 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
       if (ctx->encoding == PUBKEY_ENC_OAEP)
        {
          /* Get HASH-ALGO. */
       if (ctx->encoding == PUBKEY_ENC_OAEP)
        {
          /* Get HASH-ALGO. */
-          gcry_sexp_release (l2);
-         l2 = gcry_sexp_find_token (l1, "hash-algo", 0);
+          sexp_release (l2);
+         l2 = sexp_find_token (l1, "hash-algo", 0);
          if (l2)
            {
          if (l2)
            {
-             s = gcry_sexp_nth_data (l2, 1, &n);
+             s = sexp_nth_data (l2, 1, &n);
              if (!s)
                rc = GPG_ERR_NO_OBJ;
              else
              if (!s)
                rc = GPG_ERR_NO_OBJ;
              else
@@ -511,11 +511,11 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
            }
 
          /* Get LABEL. */
            }
 
          /* Get LABEL. */
-          gcry_sexp_release (l2);
-         l2 = gcry_sexp_find_token (l1, "label", 0);
+          sexp_release (l2);
+         l2 = sexp_find_token (l1, "label", 0);
          if (l2)
            {
          if (l2)
            {
-             s = gcry_sexp_nth_data (l2, 1, &n);
+             s = sexp_nth_data (l2, 1, &n);
              if (!s)
                rc = GPG_ERR_NO_OBJ;
              else if (n > 0)
              if (!s)
                rc = GPG_ERR_NO_OBJ;
              else if (n > 0)
@@ -535,9 +535,9 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
        }
 
       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
        }
 
       /* Get the next which has the actual data - skip HASH-ALGO and LABEL. */
-      for (i = 2; (gcry_sexp_release (l2), l2 = gcry_sexp_nth (l1, i)); i++)
+      for (i = 2; (sexp_release (l2), l2 = sexp_nth (l1, i)); i++)
        {
        {
-         s = gcry_sexp_nth_data (l2, 0, &n);
+         s = sexp_nth_data (l2, 0, &n);
          if (!(n == 9 && !memcmp (s, "hash-algo", 9))
              && !(n == 5 && !memcmp (s, "label", 5))
              && !(n == 15 && !memcmp (s, "random-override", 15)))
          if (!(n == 9 && !memcmp (s, "hash-algo", 9))
              && !(n == 5 && !memcmp (s, "label", 5))
              && !(n == 15 && !memcmp (s, "random-override", 15)))
@@ -551,7 +551,7 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
 
       /* Extract sublist identifier.  */
       gcry_free (name);
 
       /* Extract sublist identifier.  */
       gcry_free (name);
-      name = _gcry_sexp_nth_string (l2, 0);
+      name = sexp_nth_string (l2, 0);
       if (!name)
         {
           rc = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
       if (!name)
         {
           rc = GPG_ERR_INV_OBJ; /* Invalid structure of object. */
@@ -577,8 +577,8 @@ _gcry_pk_util_preparse_encval (gcry_sexp_t sexp, const char **algo_names,
 
  leave:
   gcry_free (name);
 
  leave:
   gcry_free (name);
-  gcry_sexp_release (l2);
-  gcry_sexp_release (l1);
+  sexp_release (l2);
+  sexp_release (l1);
   return rc;
 }
 
   return rc;
 }
 
@@ -650,22 +650,22 @@ _gcry_pk_util_data_to_mpi (gcry_sexp_t input, gcry_mpi_t *ret_mpi,
   int parsed_flags = 0;
 
   *ret_mpi = NULL;
   int parsed_flags = 0;
 
   *ret_mpi = NULL;
-  ldata = gcry_sexp_find_token (input, "data", 0);
+  ldata = sexp_find_token (input, "data", 0);
   if (!ldata)
     { /* assume old style */
   if (!ldata)
     { /* assume old style */
-      *ret_mpi = gcry_sexp_nth_mpi (input, 0, 0);
+      *ret_mpi = sexp_nth_mpi (input, 0, 0);
       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
     }
 
   /* See whether there is a flags list.  */
   {
       return *ret_mpi ? GPG_ERR_NO_ERROR : GPG_ERR_INV_OBJ;
     }
 
   /* See whether there is a flags list.  */
   {
-    gcry_sexp_t lflags = gcry_sexp_find_token (ldata, "flags", 0);
+    gcry_sexp_t lflags = sexp_find_token (ldata, "flags", 0);
     if (lflags)
       {
         if (_gcry_pk_util_parse_flaglist (lflags,
                                           &parsed_flags, &ctx->encoding))
           unknown_flag = 1;
     if (lflags)
       {
         if (_gcry_pk_util_parse_flaglist (lflags,
                                           &parsed_flags, &ctx->encoding))
           unknown_flag = 1;
-        gcry_sexp_release (lflags);
+        sexp_release (lflags);
       }
   }
 
       }
   }
 
@@ -673,8 +673,8 @@ _gcry_pk_util_data_to_mpi (gcry_sexp_t input, gcry_mpi_t *ret_mpi,
     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
 
   /* Get HASH or MPI */
     ctx->encoding = PUBKEY_ENC_RAW; /* default to raw */
 
   /* Get HASH or MPI */
-  lhash = gcry_sexp_find_token (ldata, "hash", 0);
-  lvalue = lhash? NULL : gcry_sexp_find_token (ldata, "value", 0);
+  lhash = sexp_find_token (ldata, "hash", 0);
+  lvalue = lhash? NULL : sexp_find_token (ldata, "value", 0);
 
   if (!(!lhash ^ !lvalue))
     rc = GPG_ERR_INV_OBJ; /* none or both given */