w32: Fix build regression due to 2aa0701.
[gnupg.git] / g10 / keyid.c
index 2a9bd19..ea6ed5e 100644 (file)
@@ -1,6 +1,8 @@
 /* keyid.c - key ID and fingerprint handling
  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
  *               2004, 2006, 2010 Free Software Foundation, Inc.
+ * Copyright (C) 2014 Werner Koch
+ * Copyright (C) 2016 g10 Code GmbH
  *
  * This file is part of GnuPG.
  *
@@ -24,7 +26,6 @@
 #include <string.h>
 #include <errno.h>
 #include <time.h>
-#include <assert.h>
 
 #include "gpg.h"
 #include "util.h"
 #include "keydb.h"
 #include "i18n.h"
 #include "rmd160.h"
+#include "host2net.h"
+
 
 #define KEYID_STR_SIZE 19
 
 #ifdef HAVE_UNSIGNED_TIME_T
 # define IS_INVALID_TIME_T(a) ((a) == (time_t)(-1))
-#else 
+#else
   /* Error or 32 bit time_t and value after 2038-01-19.  */
 # define IS_INVALID_TIME_T(a) ((a) < 0)
 #endif
@@ -54,15 +57,84 @@ pubkey_letter( int algo )
     case PUBKEY_ALGO_RSA:      return 'R' ;
     case PUBKEY_ALGO_RSA_E:    return 'r' ;
     case PUBKEY_ALGO_RSA_S:    return 's' ;
-    case PUBKEY_ALGO_ELGAMAL_E: return 'g';
+    case PUBKEY_ALGO_ELGAMAL_E: return 'g' ;
     case PUBKEY_ALGO_ELGAMAL:   return 'G' ;
     case PUBKEY_ALGO_DSA:      return 'D' ;
-    case PUBKEY_ALGO_ECDSA:    return 'E' ;    // ECC DSA (sign only)
-    case PUBKEY_ALGO_ECDH:     return 'e' ;    // ECC DH (encrypt only)
+    case PUBKEY_ALGO_ECDH:     return 'e' ;    /* ECC DH (encrypt only) */
+    case PUBKEY_ALGO_ECDSA:    return 'E' ;    /* ECC DSA (sign only)   */
+    case PUBKEY_ALGO_EDDSA:    return 'E' ;    /* ECC EdDSA (sign only) */
     default: return '?';
     }
 }
 
+/* Return a string describing the public key algorithm and the
+   keysize.  For elliptic curves the functions prints the name of the
+   curve because the keysize is a property of the curve.  The string
+   is copied to the supplied buffer up a length of BUFSIZE-1.
+   Examples for the output are:
+
+   "rsa2048"  - RSA with 2048 bit
+   "elg1024"  - Elgamal with 1024 bit
+   "ed25519"  - ECC using the curve Ed25519.
+   "E_1.2.3.4"  - ECC using the unsupported curve with OID "1.2.3.4".
+   "E_1.3.6.1.4.1.11591.2.12242973" ECC with a bogus OID.
+   "unknown_N"  - Unknown OpenPGP algorithm N.
+
+   If the option --legacy-list-mode is active, the output use the
+   legacy format:
+
+   "2048R" - RSA with 2048 bit
+   "1024g" - Elgamal with 1024 bit
+   "256E"  - ECDSA using a curve with 256 bit
+
+   The macro PUBKEY_STRING_SIZE may be used to allocate a buffer with
+   a suitable size.*/
+char *
+pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize)
+{
+  const char *prefix = NULL;
+
+  if (opt.legacy_list_mode)
+    {
+      snprintf (buffer, bufsize, "%4u%c",
+                nbits_from_pk (pk), pubkey_letter (pk->pubkey_algo));
+      return buffer;
+    }
+
+  switch (pk->pubkey_algo)
+    {
+    case PUBKEY_ALGO_RSA:
+    case PUBKEY_ALGO_RSA_E:
+    case PUBKEY_ALGO_RSA_S:    prefix = "rsa"; break;
+    case PUBKEY_ALGO_ELGAMAL_E: prefix = "elg"; break;
+    case PUBKEY_ALGO_DSA:      prefix = "dsa"; break;
+    case PUBKEY_ALGO_ELGAMAL:   prefix = "xxx"; break;
+    case PUBKEY_ALGO_ECDH:
+    case PUBKEY_ALGO_ECDSA:
+    case PUBKEY_ALGO_EDDSA:     prefix = "";    break;
+    }
+
+  if (prefix && *prefix)
+    snprintf (buffer, bufsize, "%s%u", prefix, nbits_from_pk (pk));
+  else if (prefix)
+    {
+      char *curve = openpgp_oid_to_str (pk->pkey[0]);
+      const char *name = openpgp_oid_to_curve (curve, 0);
+
+      if (name)
+        snprintf (buffer, bufsize, "%s", name);
+      else if (curve)
+        snprintf (buffer, bufsize, "E_%s", curve);
+      else
+        snprintf (buffer, bufsize, "E_error");
+      xfree (curve);
+    }
+  else
+    snprintf (buffer, bufsize, "unknown_%u", (unsigned int)pk->pubkey_algo);
+
+  return buffer;
+}
+
 
 /* Hash a public key.  This function is useful for v4 fingerprints and
    for v3 or v4 key signing. */
@@ -76,13 +148,12 @@ hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
   unsigned int nbits;
   size_t nbytes;
   int npkey = pubkey_get_npkey (pk->pubkey_algo);
-  /* name OID, MPI of public point, [for ECDH only: KEK params] */
-  enum gcry_mpi_format ecc_pub_format[3] = {GCRYMPI_FMT_USG, GCRYMPI_FMT_PGP, GCRYMPI_FMT_USG};
-
-  /* Two extra bytes for the expiration date in v3 */
-  if(pk->version<4)
-    n+=2;
 
+  /* FIXME: We can avoid the extra malloc by calling only the first
+     mpi_print here which computes the required length and calling the
+     real mpi_print only at the end.  The speed advantage would only be
+     for ECC (opaque MPIs) or if we could implement an mpi_print
+     variant with a callback handler to do the hashing.  */
   if (npkey==0 && pk->pkey[0]
       && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
     {
@@ -92,18 +163,41 @@ hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
     }
   else
     {
-      for(i=0; i < npkey; i++ )
+      for (i=0; i < npkey; i++ )
         {
-         const enum gcry_mpi_format fmt = 
-            ((pk->pubkey_algo==PUBKEY_ALGO_ECDSA || pk->pubkey_algo==PUBKEY_ALGO_ECDH) ? ecc_pub_format[i] : GCRYMPI_FMT_PGP);
-
-          if (gcry_mpi_print (fmt, NULL, 0, &nbytes, pk->pkey[i]))
-            BUG ();
-          pp[i] = xmalloc (nbytes);
-          if (gcry_mpi_print (fmt, pp[i], nbytes, &nbytes, pk->pkey[i]))
-            BUG ();
-          nn[i] = nbytes;
-          n += nn[i];
+          if (!pk->pkey[i])
+            {
+              /* This case may only happen if the parsing of the MPI
+                 failed but the key was anyway created.  May happen
+                 during "gpg KEYFILE".  */
+              pp[i] = NULL;
+              nn[i] = 0;
+            }
+          else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
+            {
+              const void *p;
+
+              p = gcry_mpi_get_opaque (pk->pkey[i], &nbits);
+              pp[i] = xmalloc ((nbits+7)/8);
+              if (p)
+                memcpy (pp[i], p, (nbits+7)/8);
+              else
+                pp[i] = NULL;
+              nn[i] = (nbits+7)/8;
+              n += nn[i];
+            }
+          else
+            {
+              if (gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0,
+                                  &nbytes, pk->pkey[i]))
+                BUG ();
+              pp[i] = xmalloc (nbytes);
+              if (gcry_mpi_print (GCRYMPI_FMT_PGP, pp[i], nbytes,
+                                  &nbytes, pk->pkey[i]))
+                BUG ();
+              nn[i] = nbytes;
+              n += nn[i];
+            }
         }
     }
 
@@ -118,29 +212,23 @@ hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
   gcry_md_putc ( md, pk->timestamp >>  8 );
   gcry_md_putc ( md, pk->timestamp       );
 
-  if(pk->version<4)
-    {
-      u16 days=0;
-      if(pk->expiredate)
-       days=(u16)((pk->expiredate - pk->timestamp) / 86400L);
-      gcry_md_putc ( md, days >> 8 );
-      gcry_md_putc ( md, days );
-    }
-
   gcry_md_putc ( md, pk->pubkey_algo );
 
   if(npkey==0 && pk->pkey[0]
      && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
     {
-      gcry_md_write (md, pp[0], nn[0]);
+      if (pp[0])
+        gcry_md_write (md, pp[0], nn[0]);
     }
   else
-    for(i=0; i < npkey; i++ )
-      {
-       gcry_md_write ( md, pp[i], nn[i] );
-       xfree(pp[i]);
-      }
+    {
+      for(i=0; i < npkey; i++ )
+        {
+          if (pp[i])
+            gcry_md_write ( md, pp[i], nn[i] );
+          xfree(pp[i]);
+        }
+    }
 }
 
 
@@ -174,92 +262,171 @@ v3_keyid (gcry_mpi_t a, u32 *ki)
     BUG ();
   if (nbytes < 8) /* oops */
     ki[0] = ki[1] = 0;
-  else 
+  else
     {
       p = buffer + nbytes - 8;
-      ki[0] = (p[0] << 24) | (p[1] <<16) | (p[2] << 8) | p[3];
+      ki[0] = buf32_to_u32 (p);
       p += 4;
-      ki[1] = (p[0] << 24) | (p[1] <<16) | (p[2] << 8) | p[3];
+      ki[1] = buf32_to_u32 (p);
     }
   xfree (buffer);
   return ki[1];
 }
 
 
-size_t
-keystrlen(void)
+/* Return PK's keyid.  The memory is owned by PK.  */
+u32 *
+pk_keyid (PKT_public_key *pk)
 {
-  switch(opt.keyid_format)
+  keyid_from_pk (pk, NULL);
+
+  /* Uncomment this for help tracking down bugs related to keyid or
+     main_keyid not being set correctly.  */
+#if 0
+  if (! (pk->main_keyid[0] || pk->main_keyid[1]))
+    log_bug ("pk->main_keyid not set!\n");
+  if (keyid_cmp (pk->keyid, pk->main_keyid) == 0
+      && ! pk->flags.primary)
+    log_bug ("keyid and main_keyid are the same, but primary flag not set!\n");
+  if (keyid_cmp (pk->keyid, pk->main_keyid) != 0
+      && pk->flags.primary)
+    log_bug ("keyid and main_keyid are different, but primary flag set!\n");
+#endif
+
+  return pk->keyid;
+}
+
+/* Return the keyid of the primary key associated with PK.  The memory
+   is owned by PK.  */
+u32 *
+pk_main_keyid (PKT_public_key *pk)
+{
+  /* Uncomment this for help tracking down bugs related to keyid or
+     main_keyid not being set correctly.  */
+#if 0
+  if (! (pk->main_keyid[0] || pk->main_keyid[1]))
+    log_bug ("pk->main_keyid not set!\n");
+#endif
+
+  return pk->main_keyid;
+}
+
+/* Copy the keyid in SRC to DEST and return DEST.  */
+u32 *
+keyid_copy (u32 *dest, const u32 *src)
+{
+  dest[0] = src[0];
+  dest[1] = src[1];
+  return dest;
+}
+
+char *
+format_keyid (u32 *keyid, int format, char *buffer, int len)
+{
+  char tmp[KEYID_STR_SIZE];
+  if (! buffer)
+    {
+      buffer = tmp;
+      len = sizeof (tmp);
+    }
+
+  if (format == KF_DEFAULT)
+    format = opt.keyid_format;
+  if (format == KF_DEFAULT)
+    format = KF_NONE;
+
+  switch (format)
     {
+    case KF_NONE:
+      if (len)
+        *buffer = 0;
+      break;
+
     case KF_SHORT:
-      return 8;
+      snprintf (buffer, len, "%08lX", (ulong)keyid[1]);
+      break;
 
     case KF_LONG:
-      return 16;
+      snprintf (buffer, len, "%08lX%08lX", (ulong)keyid[0], (ulong)keyid[1]);
+      break;
 
     case KF_0xSHORT:
-      return 10;
+      snprintf (buffer, len, "0x%08lX", (ulong)keyid[1]);
+      break;
 
     case KF_0xLONG:
-      return 18;
+      snprintf (buffer, len, "0x%08lX%08lX", (ulong)keyid[0],(ulong)keyid[1]);
+      break;
 
     default:
       BUG();
     }
-}
 
+  if (buffer == tmp)
+    return xstrdup (buffer);
+  return buffer;
+}
 
-const char *
-keystr (u32 *keyid)
-{  
-  static char keyid_str[KEYID_STR_SIZE];
+size_t
+keystrlen(void)
+{
+  int format = opt.keyid_format;
+  if (format == KF_DEFAULT)
+    format = KF_NONE;
 
-  switch (opt.keyid_format)
+  switch(format)
     {
+    case KF_NONE:
+      return 0;
+
     case KF_SHORT:
-      snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
-      break;
+      return 8;
 
     case KF_LONG:
-      if (keyid[0])
-       snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX", 
-                  (ulong)keyid[0], (ulong)keyid[1]);
-      else
-       snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
-      break;
+      return 16;
 
     case KF_0xSHORT:
-      snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
-      break;
+      return 10;
 
     case KF_0xLONG:
-      if(keyid[0])
-       snprintf (keyid_str, sizeof keyid_str, "0x%08lX%08lX", 
-                  (ulong)keyid[0],(ulong)keyid[1]);
-      else
-       snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
-      break;
-      
+      return 18;
+
     default:
       BUG();
     }
-
-  return keyid_str;
 }
 
 
 const char *
+keystr (u32 *keyid)
+{
+  static char keyid_str[KEYID_STR_SIZE];
+  int format = opt.keyid_format;
+
+  if (format == KF_NONE)
+    format = KF_LONG;
+
+  return format_keyid (keyid, format, keyid_str, sizeof (keyid_str));
+}
+
+/* This function returns the key id of the main and possible the
+ * subkey as one string.  It is used by error messages.  */
+const char *
 keystr_with_sub (u32 *main_kid, u32 *sub_kid)
-{  
+{
   static char buffer[KEYID_STR_SIZE+1+KEYID_STR_SIZE];
   char *p;
+  int format = opt.keyid_format;
 
-  mem2str (buffer, keystr (main_kid), KEYID_STR_SIZE);
+  if (format == KF_NONE)
+    format = KF_LONG;
+
+  format_keyid (main_kid, format, buffer, KEYID_STR_SIZE);
   if (sub_kid)
     {
       p = buffer + strlen (buffer);
       *p++ = '/';
-      mem2str (p, keystr (sub_kid), KEYID_STR_SIZE);
+      format_keyid (sub_kid, format, p, KEYID_STR_SIZE);
     }
   return buffer;
 }
@@ -285,6 +452,14 @@ keystr_from_pk_with_sub (PKT_public_key *main_pk, PKT_public_key *sub_pk)
 }
 
 
+/* Return PK's key id as a string using the default format.  PK owns
+   the storage.  */
+const char *
+pk_keyid_str (PKT_public_key *pk)
+{
+  return keystr (pk_keyid (pk));
+}
+
 
 const char *
 keystr_from_desc(KEYDB_SEARCH_DESC *desc)
@@ -299,15 +474,8 @@ keystr_from_desc(KEYDB_SEARCH_DESC *desc)
       {
        u32 keyid[2];
 
-       keyid[0] = ((unsigned char)desc->u.fpr[12] << 24
-                    | (unsigned char)desc->u.fpr[13] << 16
-                    | (unsigned char)desc->u.fpr[14] << 8
-                    | (unsigned char)desc->u.fpr[15]);
-       keyid[1] = ((unsigned char)desc->u.fpr[16] << 24
-                    | (unsigned char)desc->u.fpr[17] << 16
-                    | (unsigned char)desc->u.fpr[18] << 8
-                    | (unsigned char)desc->u.fpr[19]);
-
+       keyid[0] = buf32_to_u32 (desc->u.fpr+12);
+       keyid[1] = buf32_to_u32 (desc->u.fpr+16);
        return keystr(keyid);
       }
 
@@ -339,18 +507,6 @@ keyid_from_pk (PKT_public_key *pk, u32 *keyid)
       keyid[1] = pk->keyid[1];
       lowbits = keyid[1];
     }
-  else if( pk->version < 4 )
-    {
-      if( is_RSA(pk->pubkey_algo) )
-       {
-         lowbits = (pubkey_get_npkey (pk->pubkey_algo) ?
-                     v3_keyid ( pk->pkey[0], keyid ) : 0); /* From n. */
-         pk->keyid[0] = keyid[0];
-         pk->keyid[1] = keyid[1];
-       }
-      else
-       pk->keyid[0]=pk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
-    }
   else
     {
       const byte *dp;
@@ -360,8 +516,8 @@ keyid_from_pk (PKT_public_key *pk, u32 *keyid)
       if(md)
        {
          dp = gcry_md_read ( md, 0 );
-         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
-         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
+         keyid[0] = buf32_to_u32 (dp+12);
+         keyid[1] = buf32_to_u32 (dp+16);
          lowbits = keyid[1];
          gcry_md_close (md);
          pk->keyid[0] = keyid[0];
@@ -394,7 +550,7 @@ keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
       int rc;
 
       memset (&pk, 0, sizeof pk);
-      rc = get_pubkey_byfprint (&pk, fprint, fprint_len);
+      rc = get_pubkey_byfprint (&pk, NULL, fprint, fprint_len);
       if( rc )
         {
           log_error("Oops: keyid_from_fingerprint: no pubkey\n");
@@ -404,11 +560,11 @@ keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
       else
         keyid_from_pk (&pk, keyid);
     }
-  else 
+  else
     {
       const byte *dp = fprint;
-      keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
-      keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
+      keyid[0] = buf32_to_u32 (dp+12);
+      keyid[1] = buf32_to_u32 (dp+16);
     }
 
   return keyid[1];
@@ -418,7 +574,7 @@ keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
 u32
 keyid_from_sig (PKT_signature *sig, u32 *keyid)
 {
-  if( keyid ) 
+  if( keyid )
     {
       keyid[0] = sig->keyid[0];
       keyid[1] = sig->keyid[1];
@@ -433,13 +589,13 @@ namehash_from_uid (PKT_user_id *uid)
   if (!uid->namehash)
     {
       uid->namehash = xmalloc (20);
-      
+
       if (uid->attrib_data)
        rmd160_hash_buffer (uid->namehash, uid->attrib_data, uid->attrib_len);
       else
        rmd160_hash_buffer (uid->namehash, uid->name, uid->len);
     }
-  
+
   return uid->namehash;
 }
 
@@ -461,7 +617,7 @@ mk_datestr (char *buffer, time_t atime)
 
   if (IS_INVALID_TIME_T (atime))
     strcpy (buffer, "????" "-??" "-??"); /* Mark this as invalid. */
-  else 
+  else
     {
       tp = gmtime (&atime);
       sprintf (buffer,"%04d-%02d-%02d",
@@ -481,7 +637,7 @@ datestr_from_pk (PKT_public_key *pk)
 {
   static char buffer[11+5];
   time_t atime = pk->timestamp;
-  
+
   return mk_datestr (buffer, atime);
 }
 
@@ -514,7 +670,7 @@ expirestr_from_sig (PKT_signature *sig)
 {
   static char buffer[11+5];
   time_t atime;
-  
+
   if (!sig->expiredate)
     return _("never     ");
   atime=sig->expiredate;
@@ -536,7 +692,7 @@ revokestr_from_pk( PKT_public_key *pk )
 
 
 const char *
-usagestr_from_pk( PKT_public_key *pk )
+usagestr_from_pk (PKT_public_key *pk, int fill)
 {
   static char buffer[10];
   int i = 0;
@@ -554,7 +710,7 @@ usagestr_from_pk( PKT_public_key *pk )
   if ( (use & PUBKEY_USAGE_AUTH) )
     buffer[i++] = 'A';
 
-  while (i < 4)
+  while (fill && i < 4)
     buffer[i++] = ' ';
 
   buffer[i] = 0;
@@ -587,7 +743,7 @@ const char *
 colon_datestr_from_sig (PKT_signature *sig)
 {
   static char buf[20];
-  
+
   snprintf (buf, sizeof buf, "%lu", (ulong)sig->timestamp);
   return buf;
 }
@@ -613,84 +769,116 @@ colon_expirestr_from_sig (PKT_signature *sig)
 byte *
 fingerprint_from_pk (PKT_public_key *pk, byte *array, size_t *ret_len)
 {
-  byte *buf;
   const byte *dp;
-  size_t len, nbytes;
-  int i;
-  
-  if ( pk->version < 4 )
+  size_t len;
+  gcry_md_hd_t md;
+
+  md = do_fingerprint_md(pk);
+  dp = gcry_md_read( md, 0 );
+  len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
+  log_assert( len <= MAX_FINGERPRINT_LEN );
+  if (!array)
+    array = xmalloc ( len );
+  memcpy (array, dp, len );
+  pk->keyid[0] = buf32_to_u32 (dp+12);
+  pk->keyid[1] = buf32_to_u32 (dp+16);
+  gcry_md_close( md);
+
+  if (ret_len)
+    *ret_len = len;
+  return array;
+}
+
+
+/* Return an allocated buffer with the fingerprint of PK formatted as
+   a plain hexstring.  If BUFFER is NULL the result is a malloc'd
+   string.  If BUFFER is not NULL the result will be copied into this
+   buffer.  In the latter case BUFLEN describes the length of the
+   buffer; if this is too short the function terminates the process.
+   Returns a malloc'ed string or BUFFER.  A suitable length for BUFFER
+   is (2*MAX_FINGERPRINT_LEN + 1). */
+char *
+hexfingerprint (PKT_public_key *pk, char *buffer, size_t buflen)
+{
+  unsigned char fpr[MAX_FINGERPRINT_LEN];
+  size_t len;
+
+  fingerprint_from_pk (pk, fpr, &len);
+  if (!buffer)
+    buffer = xmalloc (2 * len + 1);
+  else if (buflen < 2*len+1)
+    log_fatal ("%s: buffer too short (%zu)\n", __func__, buflen);
+  bin2hex (fpr, len, buffer);
+  return buffer;
+}
+
+
+/* Pretty print a hex fingerprint.  If BUFFER is NULL the result is a
+   malloc'd string.  If BUFFER is not NULL the result will be copied
+   into this buffer.  In the latter case BUFLEN describes the length
+   of the buffer; if this is too short the function terminates the
+   process.  Returns a malloc'ed string or BUFFER.  A suitable length
+   for BUFFER is (MAX_FORMATTED_FINGERPRINT_LEN + 1).  */
+char *
+format_hexfingerprint (const char *fingerprint, char *buffer, size_t buflen)
+{
+  int hexlen = strlen (fingerprint);
+  int space;
+  int i, j;
+
+  if (hexlen == 40)  /* v4 fingerprint */
     {
-      if ( is_RSA(pk->pubkey_algo) )
-        {
-          /* RSA in version 3 packets is special. */
-          gcry_md_hd_t md;
-          
-          if (gcry_md_open (&md, DIGEST_ALGO_MD5, 0))
-            BUG ();
-          if ( pubkey_get_npkey (pk->pubkey_algo) > 1 ) 
-            {
-              for (i=0; i < 2; i++)
-                {
-                  if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, 
-                                      &nbytes, pk->pkey[i]))
-                    BUG ();
-                  /* fixme: Better allocate BUF on the stack */
-                  buf = xmalloc (nbytes);
-                  if (gcry_mpi_print (GCRYMPI_FMT_USG, buf, nbytes,
-                                      NULL, pk->pkey[i]))
-                    BUG ();
-                  gcry_md_write (md, buf, nbytes);
-                  xfree (buf);
-                }
-            }
-          gcry_md_final (md);
-          if (!array)
-            array = xmalloc (16);
-          len = 16;
-          memcpy (array, gcry_md_read (md, DIGEST_ALGO_MD5), 16);
-          gcry_md_close(md);
-        }
-      else
+      space = (/* The characters and the NUL.  */
+              40 + 1
+              /* After every fourth character, we add a space (except
+                 the last).  */
+              + 40 / 4 - 1
+              /* Half way through we add a second space.  */
+              + 1);
+    }
+  else  /* Other fingerprint versions - print as is.  */
+    {
+      space = hexlen + 1;
+    }
+
+  if (!buffer)
+    buffer = xmalloc (space);
+  else if (buflen < space)
+    log_fatal ("%s: buffer too short (%zu)\n", __func__, buflen);
+
+  if (hexlen == 40)  /* v4 fingerprint */
+    {
+      for (i = 0, j = 0; i < 40; i ++)
         {
-          if (!array)
-            array = xmalloc(16);
-          len = 16;
-          memset (array,0,16);
+          if (i && i % 4 == 0)
+            buffer[j ++] = ' ';
+          if (i == 40 / 2)
+            buffer[j ++] = ' ';
+
+          buffer[j ++] = fingerprint[i];
         }
+      buffer[j ++] = 0;
+      log_assert (j == space);
     }
-  else 
+  else
     {
-      gcry_md_hd_t md;
-      
-      md = do_fingerprint_md(pk);
-      dp = gcry_md_read( md, 0 );
-      len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
-      assert( len <= MAX_FINGERPRINT_LEN );
-      if (!array)
-        array = xmalloc ( len );
-      memcpy (array, dp, len );
-      pk->keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
-      pk->keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
-      gcry_md_close( md);
+      strcpy (buffer, fingerprint);
     }
-  
-  *ret_len = len;
-  return array;
-}
-
 
+  return buffer;
+}
 
 
 \f
 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
    key parameters expressed as an canoncial encoded S-Exp.  ARRAY must
-   be 20 bytes long.  Returns 0 on sucess or an error code.  */
+   be 20 bytes long.  Returns 0 on success or an error code.  */
 gpg_error_t
 keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
 {
   gpg_error_t err;
   gcry_sexp_t s_pkey;
-  
+
   if (DBG_PACKET)
     log_debug ("get_keygrip for public key\n");
 
@@ -718,31 +906,40 @@ keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
                              pk->pkey[0], pk->pkey[1]);
       break;
 
+    case PUBKEY_ALGO_EDDSA:
     case PUBKEY_ALGO_ECDSA:
     case PUBKEY_ALGO_ECDH:
-      err = gcry_sexp_build (&s_pkey, NULL,
-                             "(public-key(ecc(c%m)(q%m)))",
-                             pk->pkey[0], pk->pkey[1]);
-      break;
-/* 
-   case PUBKEY_ALGO_ECDH:
-      err = gcry_sexp_build (&s_pkey, NULL,
-                             "(public-key(ecdh(c%m)(q%m)(p%m)))",
-                             pk->pkey[0], pk->pkey[1], pk->pkey[2]);
+      {
+        char *curve = openpgp_oid_to_str (pk->pkey[0]);
+        if (!curve)
+          err = gpg_error_from_syserror ();
+        else
+          {
+            err = gcry_sexp_build (&s_pkey, NULL,
+                                   pk->pubkey_algo == PUBKEY_ALGO_EDDSA?
+                                   "(public-key(ecc(curve%s)(flags eddsa)(q%m)))":
+                                   (pk->pubkey_algo == PUBKEY_ALGO_ECDH
+                                    && openpgp_oid_is_cv25519 (pk->pkey[0]))?
+                                   "(public-key(ecc(curve%s)(flags djb-tweak)(q%m)))":
+                                   "(public-key(ecc(curve%s)(q%m)))",
+                                   curve, pk->pkey[1]);
+            xfree (curve);
+          }
+      }
       break;
-*/
 
     default:
       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
       break;
     }
-  
+
   if (err)
     return err;
 
   if (!gcry_pk_get_keygrip (s_pkey, array))
     {
-      log_error ("error computing keygrip\n");
+      log_info ("error computing keygrip\n");
+      memset (array, 0, 20);
       err = gpg_error (GPG_ERR_GENERAL);
     }
   else
@@ -752,8 +949,8 @@ keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
       /* FIXME: Save the keygrip in PK.  */
     }
   gcry_sexp_release (s_pkey);
-  
-  return 0;
+
+  return err;
 }
 
 
@@ -780,4 +977,3 @@ hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip)
     }
   return err;
 }
-