diff --git a/common/sexputil.c b/common/sexputil.c
index 02e52d0ed..d3020e169 100644
--- a/common/sexputil.c
+++ b/common/sexputil.c
@@ -1,579 +1,637 @@
 /* sexputil.c - Utility functions for S-expressions.
  * Copyright (C) 2005, 2007, 2009 Free Software Foundation, Inc.
  * Copyright (C) 2013 Werner Koch
  *
  * This file is part of GnuPG.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of either
  *
  *   - the GNU Lesser General Public License as published by the Free
  *     Software Foundation; either version 3 of the License, or (at
  *     your option) any later version.
  *
  * or
  *
  *   - the GNU General Public License as published by the Free
  *     Software Foundation; either version 2 of the License, or (at
  *     your option) any later version.
  *
  * or both in parallel, as here.
  *
  * This file is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  */
 
 /* This file implements a few utility functions useful when working
    with canonical encrypted S-expressions (i.e. not the S-exprssion
    objects from libgcrypt).  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <errno.h>
 #ifdef HAVE_LOCALE_H
 #include <locale.h>
 #endif
 
 #include "util.h"
 #include "tlv.h"
 #include "sexp-parse.h"
 #include "openpgpdefs.h"  /* for pubkey_algo_t */
 
 
 /* Return a malloced string with the S-expression CANON in advanced
    format.  Returns NULL on error.  */
 static char *
 sexp_to_string (gcry_sexp_t sexp)
 {
   size_t n;
   char *result;
 
   if (!sexp)
     return NULL;
   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
   if (!n)
     return NULL;
   result = xtrymalloc (n);
   if (!result)
     return NULL;
   n = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, result, n);
   if (!n)
     BUG ();
 
   return result;
 }
 
 
 /* Return a malloced string with the S-expression CANON in advanced
    format.  Returns NULL on error.  */
 char *
 canon_sexp_to_string (const unsigned char *canon, size_t canonlen)
 {
   size_t n;
   gcry_sexp_t sexp;
   char *result;
 
   n = gcry_sexp_canon_len (canon, canonlen, NULL, NULL);
   if (!n)
     return NULL;
   if (gcry_sexp_sscan (&sexp, NULL, canon, n))
     return NULL;
   result = sexp_to_string (sexp);
   gcry_sexp_release (sexp);
   return result;
 }
 
 
 /* Print the canonical encoded S-expression in SEXP in advanced
    format.  SEXPLEN may be passed as 0 is SEXP is known to be valid.
    With TEXT of NULL print just the raw S-expression, with TEXT just
    an empty string, print a trailing linefeed, otherwise print an
    entire debug line. */
 void
 log_printcanon (const char *text, const unsigned char *sexp, size_t sexplen)
 {
   if (text && *text)
     log_debug ("%s ", text);
   if (sexp)
     {
       char *buf = canon_sexp_to_string (sexp, sexplen);
       log_printf ("%s", buf? buf : "[invalid S-expression]");
       xfree (buf);
     }
   if (text)
     log_printf ("\n");
 }
 
 
 /* Print the gcryp S-expression in SEXP in advanced format.  With TEXT
    of NULL print just the raw S-expression, with TEXT just an empty
    string, print a trailing linefeed, otherwise print an entire debug
    line. */
 void
 log_printsexp (const char *text, gcry_sexp_t sexp)
 {
   if (text && *text)
     log_debug ("%s ", text);
   if (sexp)
     {
       char *buf = sexp_to_string (sexp);
       log_printf ("%s", buf? buf : "[invalid S-expression]");
       xfree (buf);
     }
   if (text)
     log_printf ("\n");
 }
 
 
 /* Helper function to create a canonical encoded S-expression from a
    Libgcrypt S-expression object.  The function returns 0 on success
    and the malloced canonical S-expression is stored at R_BUFFER and
    the allocated length at R_BUFLEN.  On error an error code is
    returned and (NULL, 0) stored at R_BUFFER and R_BUFLEN.  If the
    allocated buffer length is not required, NULL by be used for
    R_BUFLEN.  */
 gpg_error_t
 make_canon_sexp (gcry_sexp_t sexp, unsigned char **r_buffer, size_t *r_buflen)
 {
   size_t len;
   unsigned char *buf;
 
   *r_buffer = NULL;
   if (r_buflen)
     *r_buflen = 0;;
 
   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
   if (!len)
     return gpg_error (GPG_ERR_BUG);
   buf = xtrymalloc (len);
   if (!buf)
     return gpg_error_from_syserror ();
   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, len);
   if (!len)
     return gpg_error (GPG_ERR_BUG);
 
   *r_buffer = buf;
   if (r_buflen)
     *r_buflen = len;
 
   return 0;
 }
 
 
 /* Same as make_canon_sexp but pad the buffer to multiple of 64
    bits.  If SECURE is set, secure memory will be allocated.  */
 gpg_error_t
 make_canon_sexp_pad (gcry_sexp_t sexp, int secure,
                      unsigned char **r_buffer, size_t *r_buflen)
 {
   size_t len;
   unsigned char *buf;
 
   *r_buffer = NULL;
   if (r_buflen)
     *r_buflen = 0;;
 
   len = gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, NULL, 0);
   if (!len)
     return gpg_error (GPG_ERR_BUG);
   len += (8 - len % 8) % 8;
   buf = secure? xtrycalloc_secure (1, len) : xtrycalloc (1, len);
   if (!buf)
     return gpg_error_from_syserror ();
   if (!gcry_sexp_sprint (sexp, GCRYSEXP_FMT_CANON, buf, len))
     return gpg_error (GPG_ERR_BUG);
 
   *r_buffer = buf;
   if (r_buflen)
     *r_buflen = len;
 
   return 0;
 }
 
 /* Return the so called "keygrip" which is the SHA-1 hash of the
    public key parameters expressed in a way depended on the algorithm.
 
    KEY is expected to be an canonical encoded S-expression with a
    public or private key. KEYLEN is the length of that buffer.
 
    GRIP must be at least 20 bytes long.  On success 0 is returned, on
    error an error code. */
 gpg_error_t
 keygrip_from_canon_sexp (const unsigned char *key, size_t keylen,
                          unsigned char *grip)
 {
   gpg_error_t err;
   gcry_sexp_t sexp;
 
   if (!grip)
     return gpg_error (GPG_ERR_INV_VALUE);
   err = gcry_sexp_sscan (&sexp, NULL, (const char *)key, keylen);
   if (err)
     return err;
   if (!gcry_pk_get_keygrip (sexp, grip))
     err = gpg_error (GPG_ERR_INTERNAL);
   gcry_sexp_release (sexp);
   return err;
 }
 
 
 /* Compare two simple S-expressions like "(3:foo)".  Returns 0 if they
    are identical or !0 if they are not.  Note that this function can't
    be used for sorting. */
 int
 cmp_simple_canon_sexp (const unsigned char *a_orig,
                        const unsigned char *b_orig)
 {
   const char *a = (const char *)a_orig;
   const char *b = (const char *)b_orig;
   unsigned long n1, n2;
   char *endp;
 
   if (!a && !b)
     return 0; /* Both are NULL, they are identical. */
   if (!a || !b)
     return 1; /* One is NULL, they are not identical. */
   if (*a != '(' || *b != '(')
     log_bug ("invalid S-exp in cmp_simple_canon_sexp\n");
 
   a++;
   n1 = strtoul (a, &endp, 10);
   a = endp;
   b++;
   n2 = strtoul (b, &endp, 10);
   b = endp;
 
   if (*a != ':' || *b != ':' )
     log_bug ("invalid S-exp in cmp_simple_canon_sexp\n");
   if (n1 != n2)
     return 1; /* Not the same. */
 
   for (a++, b++; n1; n1--, a++, b++)
     if (*a != *b)
       return 1; /* Not the same. */
   return 0;
 }
 
 
 /* Create a simple S-expression from the hex string at LINE.  Returns
    a newly allocated buffer with that canonical encoded S-expression
    or NULL in case of an error.  On return the number of characters
    scanned in LINE will be stored at NSCANNED.  This functions stops
    converting at the first character not representing a hexdigit. Odd
    numbers of hex digits are allowed; a leading zero is then
    assumed. If no characters have been found, NULL is returned.*/
 unsigned char *
 make_simple_sexp_from_hexstr (const char *line, size_t *nscanned)
 {
   size_t n, len;
   const char *s;
   unsigned char *buf;
   unsigned char *p;
   char numbuf[50], *numbufp;
   size_t numbuflen;
 
   for (n=0, s=line; hexdigitp (s); s++, n++)
     ;
   if (nscanned)
     *nscanned = n;
   if (!n)
     return NULL;
   len = ((n+1) & ~0x01)/2;
   numbufp = smklen (numbuf, sizeof numbuf, len, &numbuflen);
   buf = xtrymalloc (1 + numbuflen + len + 1 + 1);
   if (!buf)
     return NULL;
   buf[0] = '(';
   p = (unsigned char *)stpcpy ((char *)buf+1, numbufp);
   s = line;
   if ((n&1))
     {
       *p++ = xtoi_1 (s);
       s++;
       n--;
     }
   for (; n > 1; n -=2, s += 2)
     *p++ = xtoi_2 (s);
   *p++ = ')';
   *p = 0; /* (Not really needed.) */
 
   return buf;
 }
 
 
 /* Return the hash algorithm from a KSBA sig-val. SIGVAL is a
    canonical encoded S-expression.  Return 0 if the hash algorithm is
    not encoded in SIG-VAL or it is not supported by libgcrypt.  */
 int
 hash_algo_from_sigval (const unsigned char *sigval)
 {
   const unsigned char *s = sigval;
   size_t n;
   int depth;
   char buffer[50];
 
   if (!s || *s != '(')
     return 0; /* Invalid S-expression.  */
   s++;
   n = snext (&s);
   if (!n)
     return 0; /* Invalid S-expression.  */
   if (!smatch (&s, n, "sig-val"))
     return 0; /* Not a sig-val.  */
   if (*s != '(')
     return 0; /* Invalid S-expression.  */
   s++;
   /* Skip over the algo+parameter list.  */
   depth = 1;
   if (sskip (&s, &depth) || depth)
     return 0; /* Invalid S-expression.  */
   if (*s != '(')
     return 0; /* No further list.  */
   /* Check whether this is (hash ALGO).  */
   s++;
   n = snext (&s);
   if (!n)
     return 0; /* Invalid S-expression.  */
   if (!smatch (&s, n, "hash"))
     return 0; /* Not a "hash" keyword.  */
   n = snext (&s);
   if (!n || n+1 >= sizeof (buffer))
     return 0; /* Algorithm string is missing or too long.  */
   memcpy (buffer, s, n);
   buffer[n] = 0;
 
   return gcry_md_map_name (buffer);
 }
 
 
 /* Create a public key S-expression for an RSA public key from the
    modulus M with length MLEN and the public exponent E with length
    ELEN.  Returns a newly allocated buffer of NULL in case of a memory
    allocation problem.  If R_LEN is not NULL, the length of the
    canonical S-expression is stored there. */
 unsigned char *
 make_canon_sexp_from_rsa_pk (const void *m_arg, size_t mlen,
                              const void *e_arg, size_t elen,
                              size_t *r_len)
 {
   const unsigned char *m = m_arg;
   const unsigned char *e = e_arg;
   int m_extra = 0;
   int e_extra = 0;
   char mlen_str[35];
   char elen_str[35];
   unsigned char *keybuf, *p;
   const char part1[] = "(10:public-key(3:rsa(1:n";
   const char part2[] = ")(1:e";
   const char part3[] = ")))";
 
   /* Remove leading zeroes.  */
   for (; mlen && !*m; mlen--, m++)
     ;
   for (; elen && !*e; elen--, e++)
     ;
 
   /* Insert a leading zero if the number would be zero or interpreted
      as negative.  */
   if (!mlen || (m[0] & 0x80))
     m_extra = 1;
   if (!elen || (e[0] & 0x80))
     e_extra = 1;
 
   /* Build the S-expression.  */
   snprintf (mlen_str, sizeof mlen_str, "%u:", (unsigned int)mlen+m_extra);
   snprintf (elen_str, sizeof elen_str, "%u:", (unsigned int)elen+e_extra);
 
   keybuf = xtrymalloc (strlen (part1) + strlen (mlen_str) + mlen + m_extra
                        + strlen (part2) + strlen (elen_str) + elen + e_extra
                        + strlen (part3) + 1);
   if (!keybuf)
     return NULL;
 
   p = stpcpy (keybuf, part1);
   p = stpcpy (p, mlen_str);
   if (m_extra)
     *p++ = 0;
   memcpy (p, m, mlen);
   p += mlen;
   p = stpcpy (p, part2);
   p = stpcpy (p, elen_str);
   if (e_extra)
     *p++ = 0;
   memcpy (p, e, elen);
   p += elen;
   p = stpcpy (p, part3);
 
   if (r_len)
     *r_len = p - keybuf;
 
   return keybuf;
 }
 
 
 /* Return the parameters of a public RSA key expressed as an
    canonical encoded S-expression.  */
 gpg_error_t
 get_rsa_pk_from_canon_sexp (const unsigned char *keydata, size_t keydatalen,
                             unsigned char const **r_n, size_t *r_nlen,
                             unsigned char const **r_e, size_t *r_elen)
 {
   gpg_error_t err;
   const unsigned char *buf, *tok;
   size_t buflen, toklen;
   int depth, last_depth1, last_depth2;
   const unsigned char *rsa_n = NULL;
   const unsigned char *rsa_e = NULL;
   size_t rsa_n_len, rsa_e_len;
 
   *r_n = NULL;
   *r_nlen = 0;
   *r_e = NULL;
   *r_elen = 0;
 
   buf = keydata;
   buflen = keydatalen;
   depth = 0;
   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
     return err;
   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
     return err;
   if (!tok || toklen != 10 || memcmp ("public-key", tok, toklen))
     return gpg_error (GPG_ERR_BAD_PUBKEY);
   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
     return err;
   if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
     return err;
   if (!tok || toklen != 3 || memcmp ("rsa", tok, toklen))
     return gpg_error (GPG_ERR_WRONG_PUBKEY_ALGO);
 
   last_depth1 = depth;
   while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
          && depth && depth >= last_depth1)
     {
       if (tok)
         return gpg_error (GPG_ERR_UNKNOWN_SEXP);
       if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
         return err;
       if (tok && toklen == 1)
         {
           const unsigned char **mpi;
           size_t *mpi_len;
 
           switch (*tok)
             {
             case 'n': mpi = &rsa_n; mpi_len = &rsa_n_len; break;
             case 'e': mpi = &rsa_e; mpi_len = &rsa_e_len; break;
             default:  mpi = NULL;   mpi_len = NULL; break;
             }
           if (mpi && *mpi)
             return gpg_error (GPG_ERR_DUP_VALUE);
 
           if ((err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen)))
             return err;
           if (tok && mpi)
             {
               /* Strip off leading zero bytes and save. */
               for (;toklen && !*tok; toklen--, tok++)
                 ;
               *mpi = tok;
               *mpi_len = toklen;
             }
         }
 
       /* Skip to the end of the list. */
       last_depth2 = depth;
       while (!(err = parse_sexp (&buf, &buflen, &depth, &tok, &toklen))
              && depth && depth >= last_depth2)
         ;
       if (err)
         return err;
     }
 
   if (err)
     return err;
 
   if (!rsa_n || !rsa_n_len || !rsa_e || !rsa_e_len)
     return gpg_error (GPG_ERR_BAD_PUBKEY);
 
   *r_n = rsa_n;
   *r_nlen = rsa_n_len;
   *r_e = rsa_e;
   *r_elen = rsa_e_len;
   return 0;
 }
 
 
 /* Return the algo of a public KEY of SEXP. */
 int
 get_pk_algo_from_key (gcry_sexp_t key)
 {
   gcry_sexp_t list;
   const char *s;
   size_t n;
   char algoname[6];
   int algo = 0;
 
   list = gcry_sexp_nth (key, 1);
   if (!list)
     goto out;
   s = gcry_sexp_nth_data (list, 0, &n);
   if (!s)
     goto out;
   if (n >= sizeof (algoname))
     goto out;
   memcpy (algoname, s, n);
   algoname[n] = 0;
 
   algo = gcry_pk_map_name (algoname);
   if (algo == GCRY_PK_ECC)
     {
       gcry_sexp_t l1 = gcry_sexp_find_token (list, "flags", 0);
       int i;
 
       for (i = l1 ? gcry_sexp_length (l1)-1 : 0; i > 0; i--)
 	{
 	  s = gcry_sexp_nth_data (l1, i, &n);
 	  if (!s)
 	    continue; /* Not a data element. */
 
 	  if (n == 5 && !memcmp (s, "eddsa", 5))
 	    {
 	      algo = GCRY_PK_EDDSA;
 	      break;
 	    }
 	}
       gcry_sexp_release (l1);
     }
 
  out:
   gcry_sexp_release (list);
 
   return algo;
 }
 
 
 /* This is a variant of get_pk_algo_from_key but takes an canonical
  * encoded S-expression as input.  Returns a GCRYPT public key
  * identiier or 0 on error.  */
 int
 get_pk_algo_from_canon_sexp (const unsigned char *keydata, size_t keydatalen)
 {
   gcry_sexp_t sexp;
   int algo;
 
   if (gcry_sexp_sscan (&sexp, NULL, keydata, keydatalen))
     return 0;
 
   algo = get_pk_algo_from_key (sexp);
   gcry_sexp_release (sexp);
   return algo;
 }
+
+
+/* Given the public key S_PKEY, return a new buffer with a descriptive
+ * string for its algorithm.  This function may return NULL on memory
+ * error. */
+char *
+pubkey_algo_string (gcry_sexp_t s_pkey)
+{
+  const char *prefix;
+  gcry_sexp_t l1;
+  char *algoname;
+  int algo;
+  char *result;
+
+  l1 = gcry_sexp_find_token (s_pkey, "public-key", 0);
+  if (!l1)
+    return xtrystrdup ("E_no_key");
+  {
+    gcry_sexp_t l_tmp = gcry_sexp_cadr (l1);
+    gcry_sexp_release (l1);
+    l1 = l_tmp;
+  }
+  algoname = gcry_sexp_nth_string (l1, 0);
+  gcry_sexp_release (l1);
+  if (!algoname)
+    return xtrystrdup ("E_no_algo");
+
+  algo = gcry_pk_map_name (algoname);
+  switch (algo)
+    {
+    case GCRY_PK_RSA: prefix = "rsa"; break;
+    case GCRY_PK_ELG: prefix = "elg"; break;
+    case GCRY_PK_DSA: prefix = "dsa"; break;
+    case GCRY_PK_ECC: prefix = "";  break;
+    default:          prefix = NULL; break;
+    }
+
+  if (prefix && *prefix)
+    result = xtryasprintf ("%s%u", prefix, gcry_pk_get_nbits (s_pkey));
+  else if (prefix)
+    {
+      const char *curve = gcry_pk_get_curve (s_pkey, 0, NULL);
+      const char *name = openpgp_oid_to_curve
+        (openpgp_curve_to_oid (curve, NULL), 0);
+
+      if (name)
+        result = xtrystrdup (name);
+      else if (curve)
+        result = xtryasprintf ("X_%s", curve);
+      else
+        result = xtrystrdup ("E_unknown");
+    }
+  else
+    result = xtryasprintf ("X_algo_%d", algo);
+
+  xfree (algoname);
+  return result;
+}
diff --git a/common/util.h b/common/util.h
index 863f9e36f..d5bb225a7 100644
--- a/common/util.h
+++ b/common/util.h
@@ -1,383 +1,384 @@
 /* util.h - Utility functions for GnuPG
  * Copyright (C) 2001, 2002, 2003, 2004, 2009 Free Software Foundation, Inc.
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute and/or modify this
  * part of GnuPG under the terms of either
  *
  *   - the GNU Lesser General Public License as published by the Free
  *     Software Foundation; either version 3 of the License, or (at
  *     your option) any later version.
  *
  * or
  *
  *   - the GNU General Public License as published by the Free
  *     Software Foundation; either version 2 of the License, or (at
  *     your option) any later version.
  *
  * or both in parallel, as here.
  *
  * GnuPG is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * General Public License for more details.
  *
  * You should have received a copies of the GNU General Public License
  * and the GNU Lesser General Public License along with this program;
  * if not, see <https://www.gnu.org/licenses/>.
  */
 
 #ifndef GNUPG_COMMON_UTIL_H
 #define GNUPG_COMMON_UTIL_H
 
 #include <gcrypt.h> /* We need this for the memory function protos. */
 #include <errno.h>  /* We need errno.  */
 #include <gpg-error.h> /* We need gpg_error_t and estream. */
 
 /* These error codes are used but not defined in the required
  * libgpg-error version.  Define them here.
  * Example: (#if GPG_ERROR_VERSION_NUMBER < 0x011500 // 1.21)
  */
 
 
 /* Hash function used with libksba. */
 #define HASH_FNC ((void (*)(void *, const void*,size_t))gcry_md_write)
 
 /* The length of the keygrip.  This is a SHA-1 hash of the key
  * parameters as generated by gcry_pk_get_keygrip.  */
 #define KEYGRIP_LEN 20
 
 
 /* Get all the stuff from jnlib. */
 #include "../common/logging.h"
 #include "../common/argparse.h"
 #include "../common/stringhelp.h"
 #include "../common/mischelp.h"
 #include "../common/strlist.h"
 #include "../common/dotlock.h"
 #include "../common/utf8conv.h"
 #include "../common/dynload.h"
 #include "../common/fwddecl.h"
 #include "../common/utilproto.h"
 
 #include "gettime.h"
 
 /* Redefine asprintf by our estream version which uses our own memory
    allocator..  */
 #define asprintf gpgrt_asprintf
 #define vasprintf gpgrt_vasprintf
 
 /* Due to a bug in mingw32's snprintf related to the 'l' modifier and
    for increased portability we use our snprintf on all systems. */
 #undef snprintf
 #define snprintf gpgrt_snprintf
 
 
 /* Replacements for macros not available with libgpg-error < 1.20.  */
 
 /* We need this type even if we are not using libreadline and or we
    did not include libreadline in the current file. */
 #ifndef GNUPG_LIBREADLINE_H_INCLUDED
 typedef char **rl_completion_func_t (const char *, int, int);
 #endif /*!GNUPG_LIBREADLINE_H_INCLUDED*/
 
 
 /* Handy malloc macros - please use only them. */
 #define xtrymalloc(a)    gcry_malloc ((a))
 #define xtrymalloc_secure(a)  gcry_malloc_secure ((a))
 #define xtrycalloc(a,b)  gcry_calloc ((a),(b))
 #define xtrycalloc_secure(a,b)  gcry_calloc_secure ((a),(b))
 #define xtryrealloc(a,b) gcry_realloc ((a),(b))
 #define xtrystrdup(a)    gcry_strdup ((a))
 #define xfree(a)         gcry_free ((a))
 #define xfree_fnc        gcry_free
 
 #define xmalloc(a)       gcry_xmalloc ((a))
 #define xmalloc_secure(a)  gcry_xmalloc_secure ((a))
 #define xcalloc(a,b)     gcry_xcalloc ((a),(b))
 #define xcalloc_secure(a,b) gcry_xcalloc_secure ((a),(b))
 #define xrealloc(a,b)    gcry_xrealloc ((a),(b))
 #define xstrdup(a)       gcry_xstrdup ((a))
 
 /* For compatibility with gpg 1.4 we also define these: */
 #define xmalloc_clear(a) gcry_xcalloc (1, (a))
 #define xmalloc_secure_clear(a) gcry_xcalloc_secure (1, (a))
 
 /* The default error source of the application.  This is different
    from GPG_ERR_SOURCE_DEFAULT in that it does not depend on the
    source file and thus is usable in code shared by applications.
    Defined by init.c.  */
 extern gpg_err_source_t default_errsource;
 
 /* Convenience function to return a gpg-error code for memory
    allocation failures.  This function makes sure that an error will
    be returned even if accidentally ERRNO is not set.  */
 static inline gpg_error_t
 out_of_core (void)
 {
   return gpg_error_from_syserror ();
 }
 
 
 /*-- yesno.c --*/
 int answer_is_yes (const char *s);
 int answer_is_yes_no_default (const char *s, int def_answer);
 int answer_is_yes_no_quit (const char *s);
 int answer_is_okay_cancel (const char *s, int def_answer);
 
 /*-- xreadline.c --*/
 ssize_t read_line (FILE *fp,
                    char **addr_of_buffer, size_t *length_of_buffer,
                    size_t *max_length);
 
 
 /*-- b64enc.c and b64dec.c --*/
 struct b64state
 {
   unsigned int flags;
   int idx;
   int quad_count;
   FILE *fp;
   estream_t stream;
   char *title;
   unsigned char radbuf[4];
   u32 crc;
   int stop_seen:1;
   int invalid_encoding:1;
   gpg_error_t lasterr;
 };
 
 gpg_error_t b64enc_start (struct b64state *state, FILE *fp, const char *title);
 gpg_error_t b64enc_start_es (struct b64state *state, estream_t fp,
                              const char *title);
 gpg_error_t b64enc_write (struct b64state *state,
                           const void *buffer, size_t nbytes);
 gpg_error_t b64enc_finish (struct b64state *state);
 
 gpg_error_t b64dec_start (struct b64state *state, const char *title);
 gpg_error_t b64dec_proc (struct b64state *state, void *buffer, size_t length,
                          size_t *r_nbytes);
 gpg_error_t b64dec_finish (struct b64state *state);
 
 /*-- sexputil.c */
 char *canon_sexp_to_string (const unsigned char *canon, size_t canonlen);
 void log_printcanon (const char *text,
                      const unsigned char *sexp, size_t sexplen);
 void log_printsexp (const char *text, gcry_sexp_t sexp);
 
 gpg_error_t make_canon_sexp (gcry_sexp_t sexp,
                              unsigned char **r_buffer, size_t *r_buflen);
 gpg_error_t make_canon_sexp_pad (gcry_sexp_t sexp, int secure,
                                  unsigned char **r_buffer, size_t *r_buflen);
 gpg_error_t keygrip_from_canon_sexp (const unsigned char *key, size_t keylen,
                                      unsigned char *grip);
 int cmp_simple_canon_sexp (const unsigned char *a, const unsigned char *b);
 unsigned char *make_simple_sexp_from_hexstr (const char *line,
                                              size_t *nscanned);
 int hash_algo_from_sigval (const unsigned char *sigval);
 unsigned char *make_canon_sexp_from_rsa_pk (const void *m, size_t mlen,
                                             const void *e, size_t elen,
                                             size_t *r_len);
 gpg_error_t get_rsa_pk_from_canon_sexp (const unsigned char *keydata,
                                         size_t keydatalen,
                                         unsigned char const **r_n,
                                         size_t *r_nlen,
                                         unsigned char const **r_e,
                                         size_t *r_elen);
 
 int get_pk_algo_from_key (gcry_sexp_t key);
 int get_pk_algo_from_canon_sexp (const unsigned char *keydata,
                                  size_t keydatalen);
+char *pubkey_algo_string (gcry_sexp_t s_pkey);
 
 /*-- convert.c --*/
 int hex2bin (const char *string, void *buffer, size_t length);
 int hexcolon2bin (const char *string, void *buffer, size_t length);
 char *bin2hex (const void *buffer, size_t length, char *stringbuf);
 char *bin2hexcolon (const void *buffer, size_t length, char *stringbuf);
 const char *hex2str (const char *hexstring,
                      char *buffer, size_t bufsize, size_t *buflen);
 char *hex2str_alloc (const char *hexstring, size_t *r_count);
 
 /*-- percent.c --*/
 char *percent_plus_escape (const char *string);
 char *percent_data_escape (int plus, const char *prefix,
                            const void *data, size_t datalen);
 char *percent_plus_unescape (const char *string, int nulrepl);
 char *percent_unescape (const char *string, int nulrepl);
 
 size_t percent_plus_unescape_inplace (char *string, int nulrepl);
 size_t percent_unescape_inplace (char *string, int nulrepl);
 
 /*-- openpgp-oid.c --*/
 gpg_error_t openpgp_oid_from_str (const char *string, gcry_mpi_t *r_mpi);
 char *openpgp_oidbuf_to_str (const unsigned char *buf, size_t len);
 char *openpgp_oid_to_str (gcry_mpi_t a);
 int openpgp_oidbuf_is_ed25519 (const void *buf, size_t len);
 int openpgp_oid_is_ed25519 (gcry_mpi_t a);
 int openpgp_oidbuf_is_cv25519 (const void *buf, size_t len);
 int openpgp_oid_is_cv25519 (gcry_mpi_t a);
 const char *openpgp_curve_to_oid (const char *name, unsigned int *r_nbits);
 const char *openpgp_oid_to_curve (const char *oid, int canon);
 const char *openpgp_enum_curves (int *idxp);
 const char *openpgp_is_curve_supported (const char *name,
                                         int *r_algo, unsigned int *r_nbits);
 
 
 /*-- homedir.c --*/
 const char *standard_homedir (void);
 const char *default_homedir (void);
 void gnupg_set_homedir (const char *newdir);
 const char *gnupg_homedir (void);
 int gnupg_default_homedir_p (void);
 const char *gnupg_daemon_rootdir (void);
 const char *gnupg_socketdir (void);
 const char *gnupg_sysconfdir (void);
 const char *gnupg_bindir (void);
 const char *gnupg_libexecdir (void);
 const char *gnupg_libdir (void);
 const char *gnupg_datadir (void);
 const char *gnupg_localedir (void);
 const char *gnupg_cachedir (void);
 const char *dirmngr_socket_name (void);
 
 char *_gnupg_socketdir_internal (int skip_checks, unsigned *r_info);
 
 /* All module names.  We also include gpg and gpgsm for the sake for
    gpgconf. */
 #define GNUPG_MODULE_NAME_AGENT        1
 #define GNUPG_MODULE_NAME_PINENTRY     2
 #define GNUPG_MODULE_NAME_SCDAEMON     3
 #define GNUPG_MODULE_NAME_DIRMNGR      4
 #define GNUPG_MODULE_NAME_PROTECT_TOOL 5
 #define GNUPG_MODULE_NAME_CHECK_PATTERN 6
 #define GNUPG_MODULE_NAME_GPGSM         7
 #define GNUPG_MODULE_NAME_GPG           8
 #define GNUPG_MODULE_NAME_CONNECT_AGENT 9
 #define GNUPG_MODULE_NAME_GPGCONF       10
 #define GNUPG_MODULE_NAME_DIRMNGR_LDAP  11
 #define GNUPG_MODULE_NAME_GPGV          12
 const char *gnupg_module_name (int which);
 void gnupg_module_name_flush_some (void);
 void gnupg_set_builddir (const char *newdir);
 
 
 /* A list of constants to identify protocols.  This is used by tools
  * which need to distinguish between the different protocols
  * implemented by GnuPG.  May be used as bit flags.  */
 #define GNUPG_PROTOCOL_OPENPGP    1   /* The one and only (gpg).      */
 #define GNUPG_PROTOCOL_CMS        2   /* The core of S/MIME (gpgsm)   */
 #define GNUPG_PROTOCOL_SSH_AGENT  4   /* Out ssh-agent implementation */
 
 
 /*-- gpgrlhelp.c --*/
 void gnupg_rl_initialize (void);
 
 /*-- helpfile.c --*/
 char *gnupg_get_help_string (const char *key, int only_current_locale);
 
 /*-- localename.c --*/
 const char *gnupg_messages_locale_name (void);
 
 /*-- miscellaneous.c --*/
 
 /* This function is called at startup to tell libgcrypt to use our own
    logging subsystem. */
 void setup_libgcrypt_logging (void);
 
 /* Print an out of core message and die.  */
 void xoutofcore (void);
 
 /* Same as estream_asprintf but die on memory failure.  */
 char *xasprintf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
 /* This is now an alias to estream_asprintf.  */
 char *xtryasprintf (const char *fmt, ...) GPGRT_ATTR_PRINTF(1,2);
 
 /* Replacement for gcry_cipher_algo_name.  */
 const char *gnupg_cipher_algo_name (int algo);
 
 void obsolete_option (const char *configname, unsigned int configlineno,
                       const char *name);
 
 const char *print_fname_stdout (const char *s);
 const char *print_fname_stdin (const char *s);
 void print_utf8_buffer3 (estream_t fp, const void *p, size_t n,
                          const char *delim);
 void print_utf8_buffer2 (estream_t fp, const void *p, size_t n, int delim);
 void print_utf8_buffer (estream_t fp, const void *p, size_t n);
 void print_utf8_string (estream_t stream, const char *p);
 void print_hexstring (FILE *fp, const void *buffer, size_t length,
                       int reserved);
 char *try_make_printable_string (const void *p, size_t n, int delim);
 char *make_printable_string (const void *p, size_t n, int delim);
 char *decode_c_string (const char *src);
 
 int is_file_compressed (const char *s, int *ret_rc);
 
 int match_multistr (const char *multistr,const char *match);
 
 int gnupg_compare_version (const char *a, const char *b);
 
 struct debug_flags_s
 {
   unsigned int flag;
   const char *name;
 };
 int parse_debug_flag (const char *string, unsigned int *debugvar,
                       const struct debug_flags_s *flags);
 
 
 /*-- Simple replacement functions. */
 
 /* We use the gnupg_ttyname macro to be safe not to run into conflicts
    which an extisting but broken ttyname.  */
 #if !defined(HAVE_TTYNAME) || defined(HAVE_BROKEN_TTYNAME)
 # define gnupg_ttyname(n) _gnupg_ttyname ((n))
 /* Systems without ttyname (W32) will merely return NULL. */
 static inline char *
 _gnupg_ttyname (int fd)
 {
   (void)fd;
   return NULL;
 }
 #else /*HAVE_TTYNAME*/
 # define gnupg_ttyname(n) ttyname ((n))
 #endif /*HAVE_TTYNAME */
 
 #ifdef HAVE_W32CE_SYSTEM
 #define getpid() GetCurrentProcessId ()
 char *_gnupg_getenv (const char *name); /* See sysutils.c */
 #define getenv(a)  _gnupg_getenv ((a))
 char *_gnupg_setenv (const char *name); /* See sysutils.c */
 #define setenv(a,b,c)  _gnupg_setenv ((a),(b),(c))
 int _gnupg_isatty (int fd);
 #define gnupg_isatty(a)  _gnupg_isatty ((a))
 #else
 #define gnupg_isatty(a)  isatty ((a))
 #endif
 
 
 
 /*-- Macros to replace ctype ones to avoid locale problems. --*/
 #define spacep(p)   (*(p) == ' ' || *(p) == '\t')
 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
 #define alphap(p)   ((*(p) >= 'A' && *(p) <= 'Z')       \
                      || (*(p) >= 'a' && *(p) <= 'z'))
 #define alnump(p)   (alphap (p) || digitp (p))
 #define hexdigitp(a) (digitp (a)                     \
                       || (*(a) >= 'A' && *(a) <= 'F')  \
                       || (*(a) >= 'a' && *(a) <= 'f'))
   /* Note this isn't identical to a C locale isspace() without \f and
      \v, but works for the purposes used here. */
 #define ascii_isspace(a) ((a)==' ' || (a)=='\n' || (a)=='\r' || (a)=='\t')
 
 /* The atoi macros assume that the buffer has only valid digits. */
 #define atoi_1(p)   (*(p) - '0' )
 #define atoi_2(p)   ((atoi_1(p) * 10) + atoi_1((p)+1))
 #define atoi_4(p)   ((atoi_2(p) * 100) + atoi_2((p)+2))
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 #define xtoi_4(p)   ((xtoi_2(p) * 256) + xtoi_2((p)+2))
 
 #endif /*GNUPG_COMMON_UTIL_H*/
diff --git a/tools/card-tool-misc.c b/tools/card-tool-misc.c
index 5e0461cb8..06fcb6705 100644
--- a/tools/card-tool-misc.c
+++ b/tools/card-tool-misc.c
@@ -1,137 +1,79 @@
 /* card-tool-misc.c - Helper functions for gpg-card-tool
  * Copyright (C) 2019 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * GnuPG is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * GnuPG is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #include <config.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
 
 #include "../common/util.h"
 #include "../common/i18n.h"
 #include "../common/openpgpdefs.h"
 #include "card-tool.h"
 
 /* Return the key info object for the key KEYREF.  If it is not found
  * NULL is returned.  */
 key_info_t
 find_kinfo (card_info_t info, const char *keyref)
 {
   key_info_t kinfo;
 
   for (kinfo = info->kinfo; kinfo; kinfo = kinfo->next)
     if (!strcmp (kinfo->keyref, keyref))
       return kinfo;
   return NULL;
 }
 
 
 /* Convert STRING into a newly allocated buffer while translating the
  * hex numbers.  Blanks and colons are allowed to separate pairs of
  * hex digits.  Returns NULL on error or a newly malloced buffer and
  * its length in LENGTH.  */
 void *
 hex_to_buffer (const char *string, size_t *r_length)
 {
   unsigned char *buffer;
   const char *s;
   size_t n;
 
   buffer = xtrymalloc (strlen (string)+1);
   if (!buffer)
     return NULL;
   for (s=string, n=0; *s; s++)
     {
       if (ascii_isspace (*s) || *s == ':')
         continue;
       if (hexdigitp (s) && hexdigitp (s+1))
         {
           buffer[n++] = xtoi_2 (s);
           s++;
         }
       else
         {
           xfree (buffer);
           gpg_err_set_errno (EINVAL);
           return NULL;
         }
     }
   *r_length = n;
   return buffer;
 }
-
-
-
-/* Given the public key S_PKEY, return a new buffer with a descriptive
- * string for its algorithm.  This function always returns a string. */
-char *
-pubkey_algo_string (gcry_sexp_t s_pkey)
-{
-  const char *prefix;
-  gcry_sexp_t l1;
-  char *algoname;
-  int algo;
-  char *result;
-
-  l1 = gcry_sexp_find_token (s_pkey, "public-key", 0);
-  if (!l1)
-    return xstrdup ("E_no_key");
-  {
-    gcry_sexp_t l_tmp = gcry_sexp_cadr (l1);
-    gcry_sexp_release (l1);
-    l1 = l_tmp;
-  }
-  algoname = gcry_sexp_nth_string (l1, 0);
-  gcry_sexp_release (l1);
-  if (!algoname)
-    return xstrdup ("E_no_algo");
-
-  algo = gcry_pk_map_name (algoname);
-  switch (algo)
-    {
-    case GCRY_PK_RSA: prefix = "rsa"; break;
-    case GCRY_PK_ELG: prefix = "elg"; break;
-    case GCRY_PK_DSA: prefix = "dsa"; break;
-    case GCRY_PK_ECC: prefix = "";  break;
-    default:          prefix = NULL; break;
-    }
-
-  if (prefix && *prefix)
-    result = xasprintf ("%s%u", prefix, gcry_pk_get_nbits (s_pkey));
-  else if (prefix)
-    {
-      const char *curve = gcry_pk_get_curve (s_pkey, 0, NULL);
-      const char *name = openpgp_oid_to_curve
-        (openpgp_curve_to_oid (curve, NULL), 0);
-
-      if (name)
-        result = xstrdup (name);
-      else if (curve)
-        result = xasprintf ("X_%s", curve);
-      else
-        result = xstrdup ("E_unknown");
-    }
-  else
-    result = xasprintf ("X_algo_%d", algo);
-
-  xfree (algoname);
-  return result;
-}
diff --git a/tools/card-tool.h b/tools/card-tool.h
index 9daf7e498..f49f253ce 100644
--- a/tools/card-tool.h
+++ b/tools/card-tool.h
@@ -1,225 +1,223 @@
 /* card-tool.h - Common definitions for the gpg-card-tool
  * Copyright (C) 2019 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
  * This file is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 3 of the License, or
  * (at your option) any later version.
  *
  * This file is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, see <https://gnu.org/licenses/>.
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
 #ifndef GNUPG_CARD_TOOL_H
 #define GNUPG_CARD_TOOL_H
 
 #include "../common/session-env.h"
 
 
 /* We keep all global options in the structure OPT.  */
 struct
 {
   int interactive;
   int verbose;
   unsigned int debug;
   int quiet;
   int with_colons;
   const char *gpg_program;
   const char *gpgsm_program;
   const char *agent_program;
   int autostart;
 
   /* Options passed to the gpg-agent: */
   session_env_t session_env;
   char *lc_ctype;
   char *lc_messages;
 
 } opt;
 
 /* Debug values and macros.  */
 #define DBG_IPC_VALUE      1024 /* Debug assuan communication.  */
 #define DBG_EXTPROG_VALUE 16384 /* Debug external program calls */
 
 #define DBG_IPC       (opt.debug & DBG_IPC_VALUE)
 #define DBG_EXTPROG   (opt.debug & DBG_EXTPROG_VALUE)
 
 /* The maximum length of a binary fingerprint.  */
 #define MAX_FINGERPRINT_LEN  32
 
 
 /*
  * Data structures to store keyblocks (aka certificates).
  */
 struct pubkey_s
 {
   struct pubkey_s *next;   /* The next key.  */
   unsigned char grip[KEYGRIP_LEN];
   unsigned char fpr[MAX_FINGERPRINT_LEN];
   unsigned char fprlen;     /* The used length of a FPR.  */
   unsigned int grip_valid:1;/* The grip is valid.  */
   unsigned int requested: 1;/* This is the requested grip.  */
 };
 typedef struct pubkey_s *pubkey_t;
 
 struct userid_s
 {
   struct userid_s *next;
   char *value;   /* Malloced.  */
 };
 typedef struct userid_s *userid_t;
 
 struct keyblock_s
 {
   struct keyblock_s *next;  /* Allow to link several keyblocks.  */
   int protocol;      /* GPGME_PROTOCOL_OPENPGP or _CMS. */
   pubkey_t keys;     /* The key.  For OpenPGP primary + list of subkeys.  */
   userid_t uids;     /* The list of user ids.  */
 };
 typedef struct keyblock_s *keyblock_t;
 
 
 
 /* Enumeration of the known card application types. */
 typedef enum
   {
    APP_TYPE_NONE,        /* Not yet known or for direct APDU sending.  */
    APP_TYPE_OPENPGP,
    APP_TYPE_NKS,
    APP_TYPE_DINSIG,
    APP_TYPE_P15,
    APP_TYPE_GELDKARTE,
    APP_TYPE_SC_HSM,
    APP_TYPE_PIV,
    APP_TYPE_UNKNOWN      /* Unknown by this tool.  */
   } app_type_t;
 
 
 /* OpenPGP card key attributes.  */
 struct key_attr
 {
   int algo;              /* Algorithm identifier.  */
   union {
     unsigned int nbits;  /* Supported keysize.  */
     const char *curve;   /* Name of curve.  */
   };
 };
 
 /* An object to store information pertaining to a key pair as stored
  * on a card.  This is commonly used as a linked list with all keys
  * known for the current card.  */
 struct key_info_s
 {
   struct key_info_s *next;
 
   unsigned char grip[20];/* The keygrip.  */
 
   unsigned char xflag;   /* Temporary flag to help processing a list. */
 
   /* The three next items are mostly useful for OpenPGP cards.  */
   unsigned char fprlen;  /* Use length of the next item.  */
   unsigned char fpr[32]; /* The binary fingerprint of length FPRLEN.  */
   u32 created;           /* The time the key was created.  */
 
   char keyref[1];        /* String with the keyref (e.g. OPENPGP.1).  */
 };
 typedef struct key_info_s *key_info_t;
 
 
 /*
  * The object used to store information about a card.
  */
 struct card_info_s
 {
   int initialized;   /* True if a learn command was successful. */
   int error;         /* private. */
   char *reader;      /* Reader information.  */
   char *cardtype;    /* NULL or type of the card.  */
   char *apptypestr;  /* Malloced application type string.  */
   app_type_t apptype;/* Translated from APPTYPESTR.  */
   char *serialno;    /* malloced hex string. */
   char *dispserialno;/* malloced string. */
   char *disp_name;   /* malloced. */
   char *disp_lang;   /* malloced. */
   int  disp_sex;     /* 0 = unspecified, 1 = male, 2 = female */
   char *pubkey_url;  /* malloced. */
   char *login_data;  /* malloced. */
   char *private_do[4]; /* malloced. */
   char cafpr1len;     /* Length of the CA-fingerprint or 0 if invalid.  */
   char cafpr2len;
   char cafpr3len;
   char cafpr1[20];
   char cafpr2[20];
   char cafpr3[20];
   key_info_t kinfo;  /* Linked list with all keypair related data.  */
   unsigned long sig_counter;
   int chv1_cached;   /* For openpgp this is true if a PIN is not
                         required for each signing.  Note that the
                         gpg-agent might cache it anyway. */
   int is_v2;         /* True if this is a v2 openpgp card.  */
   int chvmaxlen[3];  /* Maximum allowed length of a CHV. */
   int chvinfo[3];    /* Allowed retries for the CHV; 0 = blocked. */
   unsigned char chvusage[2]; /* Data object 5F2F */
   struct key_attr key_attr[3]; /* OpenPGP card key attributes.  */
   struct {
     unsigned int ki:1;     /* Key import available.  */
     unsigned int aac:1;    /* Algorithm attributes are changeable.  */
     unsigned int kdf:1;    /* KDF object to support PIN hashing available.  */
     unsigned int bt:1;     /* Button for confirmation available.  */
   } extcap;
   unsigned int status_indicator;
   int kdf_do_enabled;      /* True if card has a KDF object.  */
   int uif[3];              /* True if User Interaction Flag is on.  */
 };
 typedef struct card_info_s *card_info_t;
 
 
 /*-- card-tool-keys.c --*/
 void release_keyblock (keyblock_t keyblock);
 void flush_keyblock_cache (void);
 gpg_error_t get_matching_keys (const unsigned char *keygrip, int protocol,
                                keyblock_t *r_keyblock);
 gpg_error_t test_get_matching_keys (const char *hexgrip);
 
 
 /*-- card-tool-misc.c --*/
 key_info_t find_kinfo (card_info_t info, const char *keyref);
 void *hex_to_buffer (const char *string, size_t *r_length);
-char *pubkey_algo_string (gcry_sexp_t s_pkey);
-
 
 /*-- card-call-scd.c --*/
 void release_card_info (card_info_t info);
 const char *app_type_string (app_type_t app_type);
 
 gpg_error_t scd_apdu (const char *hexapdu, unsigned int *r_sw);
 gpg_error_t scd_learn (card_info_t info);
 gpg_error_t scd_getattr (const char *name, struct card_info_s *info);
 gpg_error_t scd_setattr (const char *name,
                          const unsigned char *value, size_t valuelen);
 gpg_error_t scd_writecert (const char *certidstr,
                            const unsigned char *certdata, size_t certdatalen);
 gpg_error_t scd_writekey (int keyno,
                           const unsigned char *keydata, size_t keydatalen);
 gpg_error_t scd_genkey (const char *keyref, int force, const char *algo,
                         u32 *createtime);
 gpg_error_t scd_serialno (char **r_serialno, const char *demand);
 gpg_error_t scd_readcert (const char *certidstr,
                           void **r_buf, size_t *r_buflen);
 gpg_error_t scd_readkey (const char *keyrefstr, gcry_sexp_t *r_result);
 gpg_error_t scd_cardlist (strlist_t *result);
 gpg_error_t scd_change_pin (const char *pinref, int reset_mode);
 gpg_error_t scd_checkpin (const char *serialno);
 
 unsigned long agent_get_s2k_count (void);
 
 
 
 #endif /*GNUPG_CARD_TOOL_H*/