g10/keyid.c

   1 /* keyid.c - key ID and fingerprint handling
   2  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
   3  *               2004, 2006, 2010 Free Software Foundation, Inc.
   4  * Copyright (C) 2014 Werner Koch
   5  *
   6  * This file is part of GnuPG.
   7  *
   8  * GnuPG is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * GnuPG is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include <config.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <time.h>
  28 #include <assert.h>
  29
  30 #include "gpg.h"
  31 #include "util.h"
  32 #include "main.h"
  33 #include "packet.h"
  34 #include "options.h"
  35 #include "keydb.h"
  36 #include "i18n.h"
  37 #include "rmd160.h"
  38 #include "host2net.h"
  39
  40
  41 #define KEYID_STR_SIZE 19
  42
  43 #ifdef HAVE_UNSIGNED_TIME_T
  44 # define IS_INVALID_TIME_T(a) ((a) == (time_t)(-1))
  45 #else
  46   /* Error or 32 bit time_t and value after 2038-01-19.  */
  47 # define IS_INVALID_TIME_T(a) ((a) < 0)
  48 #endif
  49
  50
  51 /* Return a letter describing the public key algorithms.  */
  52 int
  53 pubkey_letter( int algo )
  54 {
  55   switch (algo)
  56     {
  57     case PUBKEY_ALGO_RSA:       return 'R' ;
  58     case PUBKEY_ALGO_RSA_E:     return 'r' ;
  59     case PUBKEY_ALGO_RSA_S:     return 's' ;
  60     case PUBKEY_ALGO_ELGAMAL_E: return 'g' ;
  61     case PUBKEY_ALGO_ELGAMAL:   return 'G' ;
  62     case PUBKEY_ALGO_DSA:       return 'D' ;
  63     case PUBKEY_ALGO_ECDH:      return 'e' ;    /* ECC DH (encrypt only) */
  64     case PUBKEY_ALGO_ECDSA:     return 'E' ;    /* ECC DSA (sign only)   */
  65     case PUBKEY_ALGO_EDDSA:     return 'E' ;    /* ECC EdDSA (sign only) */
  66     default: return '?';
  67     }
  68 }
  69
  70 /* Return a string describing the public key algorithm and the
  71    keysize.  For elliptic curves the functions prints the name of the
  72    curve because the keysize is a property of the curve.  The string
  73    is copied to the supplied buffer up a length of BUFSIZE-1.
  74    Examples for the output are:
  75
  76    "rsa2048"  - RSA with 2048 bit
  77    "elg1024"  - Elgamal with 1024 bit
  78    "ed25519"  - ECC using the curve Ed25519.
  79    "E_1.2.3.4"  - ECC using the unsupported curve with OID "1.2.3.4".
  80    "E_1.3.6.1.4.1.11591.2.12242973" ECC with a bogus OID.
  81    "unknown_N"  - Unknown OpenPGP algorithm N.
  82
  83    If the option --legacy-list-mode is active, the output use the
  84    legacy format:
  85
  86    "2048R" - RSA with 2048 bit
  87    "1024g" - Elgamal with 1024 bit
  88    "256E"  - ECDSA using a curve with 256 bit
  89
  90    The macro PUBKEY_STRING_SIZE may be used to allocate a buffer with
  91    a suitable size.*/
  92 char *
  93 pubkey_string (PKT_public_key *pk, char *buffer, size_t bufsize)
  94 {
  95   const char *prefix = NULL;
  96
  97   if (opt.legacy_list_mode)
  98     {
  99       snprintf (buffer, bufsize, "%4u%c",
 100                 nbits_from_pk (pk), pubkey_letter (pk->pubkey_algo));
 101       return buffer;
 102     }
 103
 104   switch (pk->pubkey_algo)
 105     {
 106     case PUBKEY_ALGO_RSA:
 107     case PUBKEY_ALGO_RSA_E:
 108     case PUBKEY_ALGO_RSA_S:     prefix = "rsa"; break;
 109     case PUBKEY_ALGO_ELGAMAL_E: prefix = "elg"; break;
 110     case PUBKEY_ALGO_DSA:       prefix = "dsa"; break;
 111     case PUBKEY_ALGO_ELGAMAL:   prefix = "xxx"; break;
 112     case PUBKEY_ALGO_ECDH:
 113     case PUBKEY_ALGO_ECDSA:
 114     case PUBKEY_ALGO_EDDSA:     prefix = "";    break;
 115     }
 116
 117   if (prefix && *prefix)
 118     snprintf (buffer, bufsize, "%s%u", prefix, nbits_from_pk (pk));
 119   else if (prefix)
 120     {
 121       char *curve = openpgp_oid_to_str (pk->pkey[0]);
 122       const char *name = openpgp_oid_to_curve (curve);
 123
 124       if (*name && *name != '?')
 125         snprintf (buffer, bufsize, "%s", name);
 126       else if (curve)
 127         snprintf (buffer, bufsize, "E_%s", curve);
 128       else
 129         snprintf (buffer, bufsize, "E_error");
 130       xfree (curve);
 131     }
 132   else
 133     snprintf (buffer, bufsize, "unknown_%u", (unsigned int)pk->pubkey_algo);
 134
 135   return buffer;
 136 }
 137
 138
 139 /* Hash a public key.  This function is useful for v4 fingerprints and
 140    for v3 or v4 key signing. */
 141 void
 142 hash_public_key (gcry_md_hd_t md, PKT_public_key *pk)
 143 {
 144   unsigned int n = 6;
 145   unsigned int nn[PUBKEY_MAX_NPKEY];
 146   byte *pp[PUBKEY_MAX_NPKEY];
 147   int i;
 148   unsigned int nbits;
 149   size_t nbytes;
 150   int npkey = pubkey_get_npkey (pk->pubkey_algo);
 151
 152   /* FIXME: We can avoid the extra malloc by calling only the first
 153      mpi_print here which computes the required length and calling the
 154      real mpi_print only at the end.  The speed advantage would only be
 155      for ECC (opaque MPIs) or if we could implement an mpi_print
 156      variant with a callback handler to do the hashing.  */
 157   if (npkey==0 && pk->pkey[0]
 158       && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
 159     {
 160       pp[0] = gcry_mpi_get_opaque (pk->pkey[0], &nbits);
 161       nn[0] = (nbits+7)/8;
 162       n+=nn[0];
 163     }
 164   else
 165     {
 166       for (i=0; i < npkey; i++ )
 167         {
 168           if (!pk->pkey[i])
 169             {
 170               /* This case may only happen if the parsing of the MPI
 171                  failed but the key was anyway created.  May happen
 172                  during "gpg KEYFILE".  */
 173               pp[i] = NULL;
 174               nn[i] = 0;
 175             }
 176           else if (gcry_mpi_get_flag (pk->pkey[i], GCRYMPI_FLAG_OPAQUE))
 177             {
 178               const void *p;
 179
 180               p = gcry_mpi_get_opaque (pk->pkey[i], &nbits);
 181               pp[i] = xmalloc ((nbits+7)/8);
 182               if (p)
 183                 memcpy (pp[i], p, (nbits+7)/8);
 184               else
 185                 pp[i] = NULL;
 186               nn[i] = (nbits+7)/8;
 187               n += nn[i];
 188             }
 189           else
 190             {
 191               if (gcry_mpi_print (GCRYMPI_FMT_PGP, NULL, 0,
 192                                   &nbytes, pk->pkey[i]))
 193                 BUG ();
 194               pp[i] = xmalloc (nbytes);
 195               if (gcry_mpi_print (GCRYMPI_FMT_PGP, pp[i], nbytes,
 196                                   &nbytes, pk->pkey[i]))
 197                 BUG ();
 198               nn[i] = nbytes;
 199               n += nn[i];
 200             }
 201         }
 202     }
 203
 204   gcry_md_putc ( md, 0x99 );     /* ctb */
 205   /* What does it mean if n is greater than than 0xFFFF ? */
 206   gcry_md_putc ( md, n >> 8 );   /* 2 byte length header */
 207   gcry_md_putc ( md, n );
 208   gcry_md_putc ( md, pk->version );
 209
 210   gcry_md_putc ( md, pk->timestamp >> 24 );
 211   gcry_md_putc ( md, pk->timestamp >> 16 );
 212   gcry_md_putc ( md, pk->timestamp >>  8 );
 213   gcry_md_putc ( md, pk->timestamp       );
 214
 215   gcry_md_putc ( md, pk->pubkey_algo );
 216
 217   if(npkey==0 && pk->pkey[0]
 218      && gcry_mpi_get_flag (pk->pkey[0], GCRYMPI_FLAG_OPAQUE))
 219     {
 220       if (pp[0])
 221         gcry_md_write (md, pp[0], nn[0]);
 222     }
 223   else
 224     {
 225       for(i=0; i < npkey; i++ )
 226         {
 227           if (pp[i])
 228             gcry_md_write ( md, pp[i], nn[i] );
 229           xfree(pp[i]);
 230         }
 231     }
 232 }
 233
 234
 235 static gcry_md_hd_t
 236 do_fingerprint_md( PKT_public_key *pk )
 237 {
 238   gcry_md_hd_t md;
 239
 240   if (gcry_md_open (&md, DIGEST_ALGO_SHA1, 0))
 241     BUG ();
 242   hash_public_key(md,pk);
 243   gcry_md_final( md );
 244
 245   return md;
 246 }
 247
 248
 249 /* fixme: Check whether we can replace this function or if not
 250    describe why we need it.  */
 251 u32
 252 v3_keyid (gcry_mpi_t a, u32 *ki)
 253 {
 254   byte *buffer, *p;
 255   size_t nbytes;
 256
 257   if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, 0, &nbytes, a ))
 258     BUG ();
 259   /* fixme: allocate it on the stack */
 260   buffer = xmalloc (nbytes);
 261   if (gcry_mpi_print( GCRYMPI_FMT_USG, buffer, nbytes, NULL, a ))
 262     BUG ();
 263   if (nbytes < 8) /* oops */
 264     ki[0] = ki[1] = 0;
 265   else
 266     {
 267       p = buffer + nbytes - 8;
 268       ki[0] = buf32_to_u32 (p);
 269       p += 4;
 270       ki[1] = buf32_to_u32 (p);
 271     }
 272   xfree (buffer);
 273   return ki[1];
 274 }
 275
 276
 277 size_t
 278 keystrlen(void)
 279 {
 280   switch(opt.keyid_format)
 281     {
 282     case KF_SHORT:
 283       return 8;
 284
 285     case KF_LONG:
 286       return 16;
 287
 288     case KF_0xSHORT:
 289       return 10;
 290
 291     case KF_0xLONG:
 292       return 18;
 293
 294     default:
 295       BUG();
 296     }
 297 }
 298
 299
 300 const char *
 301 keystr (u32 *keyid)
 302 {
 303   static char keyid_str[KEYID_STR_SIZE];
 304
 305   switch (opt.keyid_format)
 306     {
 307     case KF_SHORT:
 308       snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
 309       break;
 310
 311     case KF_LONG:
 312       if (keyid[0])
 313         snprintf (keyid_str, sizeof keyid_str, "%08lX%08lX",
 314                   (ulong)keyid[0], (ulong)keyid[1]);
 315       else
 316         snprintf (keyid_str, sizeof keyid_str, "%08lX", (ulong)keyid[1]);
 317       break;
 318
 319     case KF_0xSHORT:
 320       snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
 321       break;
 322
 323     case KF_0xLONG:
 324       if(keyid[0])
 325         snprintf (keyid_str, sizeof keyid_str, "0x%08lX%08lX",
 326                   (ulong)keyid[0],(ulong)keyid[1]);
 327       else
 328         snprintf (keyid_str, sizeof keyid_str, "0x%08lX", (ulong)keyid[1]);
 329       break;
 330
 331     default:
 332       BUG();
 333     }
 334
 335   return keyid_str;
 336 }
 337
 338
 339 const char *
 340 keystr_with_sub (u32 *main_kid, u32 *sub_kid)
 341 {
 342   static char buffer[KEYID_STR_SIZE+1+KEYID_STR_SIZE];
 343   char *p;
 344
 345   mem2str (buffer, keystr (main_kid), KEYID_STR_SIZE);
 346   if (sub_kid)
 347     {
 348       p = buffer + strlen (buffer);
 349       *p++ = '/';
 350       mem2str (p, keystr (sub_kid), KEYID_STR_SIZE);
 351     }
 352   return buffer;
 353 }
 354
 355
 356 const char *
 357 keystr_from_pk(PKT_public_key *pk)
 358 {
 359   keyid_from_pk(pk,NULL);
 360
 361   return keystr(pk->keyid);
 362 }
 363
 364
 365 const char *
 366 keystr_from_pk_with_sub (PKT_public_key *main_pk, PKT_public_key *sub_pk)
 367 {
 368   keyid_from_pk (main_pk, NULL);
 369   if (sub_pk)
 370     keyid_from_pk (sub_pk, NULL);
 371
 372   return keystr_with_sub (main_pk->keyid, sub_pk? sub_pk->keyid:NULL);
 373 }
 374
 375
 376
 377 const char *
 378 keystr_from_desc(KEYDB_SEARCH_DESC *desc)
 379 {
 380   switch(desc->mode)
 381     {
 382     case KEYDB_SEARCH_MODE_LONG_KID:
 383     case KEYDB_SEARCH_MODE_SHORT_KID:
 384       return keystr(desc->u.kid);
 385
 386     case KEYDB_SEARCH_MODE_FPR20:
 387       {
 388         u32 keyid[2];
 389
 390         keyid[0] = buf32_to_u32 (desc->u.fpr+12);
 391         keyid[1] = buf32_to_u32 (desc->u.fpr+16);
 392         return keystr(keyid);
 393       }
 394
 395     case KEYDB_SEARCH_MODE_FPR16:
 396       return "?v3 fpr?";
 397
 398     default:
 399       BUG();
 400     }
 401 }
 402
 403
 404 /*
 405  * Get the keyid from the public key and put it into keyid
 406  * if this is not NULL. Return the 32 low bits of the keyid.
 407  */
 408 u32
 409 keyid_from_pk (PKT_public_key *pk, u32 *keyid)
 410 {
 411   u32 lowbits;
 412   u32 dummy_keyid[2];
 413
 414   if (!keyid)
 415     keyid = dummy_keyid;
 416
 417   if( pk->keyid[0] || pk->keyid[1] )
 418     {
 419       keyid[0] = pk->keyid[0];
 420       keyid[1] = pk->keyid[1];
 421       lowbits = keyid[1];
 422     }
 423   else
 424     {
 425       const byte *dp;
 426       gcry_md_hd_t md;
 427
 428       md = do_fingerprint_md(pk);
 429       if(md)
 430         {
 431           dp = gcry_md_read ( md, 0 );
 432           keyid[0] = buf32_to_u32 (dp+12);
 433           keyid[1] = buf32_to_u32 (dp+16);
 434           lowbits = keyid[1];
 435           gcry_md_close (md);
 436           pk->keyid[0] = keyid[0];
 437           pk->keyid[1] = keyid[1];
 438         }
 439       else
 440         pk->keyid[0]=pk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
 441     }
 442
 443   return lowbits;
 444 }
 445
 446
 447 /*
 448  * Get the keyid from the fingerprint.  This function is simple for most
 449  * keys, but has to do a keylookup for old stayle keys.
 450  */
 451 u32
 452 keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
 453 {
 454   u32 dummy_keyid[2];
 455
 456   if( !keyid )
 457     keyid = dummy_keyid;
 458
 459   if (fprint_len != 20)
 460     {
 461       /* This is special as we have to lookup the key first.  */
 462       PKT_public_key pk;
 463       int rc;
 464
 465       memset (&pk, 0, sizeof pk);
 466       rc = get_pubkey_byfprint (&pk, fprint, fprint_len);
 467       if( rc )
 468         {
 469           log_error("Oops: keyid_from_fingerprint: no pubkey\n");
 470           keyid[0] = 0;
 471           keyid[1] = 0;
 472         }
 473       else
 474         keyid_from_pk (&pk, keyid);
 475     }
 476   else
 477     {
 478       const byte *dp = fprint;
 479       keyid[0] = buf32_to_u32 (dp+12);
 480       keyid[1] = buf32_to_u32 (dp+16);
 481     }
 482
 483   return keyid[1];
 484 }
 485
 486
 487 u32
 488 keyid_from_sig (PKT_signature *sig, u32 *keyid)
 489 {
 490   if( keyid )
 491     {
 492       keyid[0] = sig->keyid[0];
 493       keyid[1] = sig->keyid[1];
 494     }
 495   return sig->keyid[1];
 496 }
 497
 498
 499 byte *
 500 namehash_from_uid (PKT_user_id *uid)
 501 {
 502   if (!uid->namehash)
 503     {
 504       uid->namehash = xmalloc (20);
 505
 506       if (uid->attrib_data)
 507         rmd160_hash_buffer (uid->namehash, uid->attrib_data, uid->attrib_len);
 508       else
 509         rmd160_hash_buffer (uid->namehash, uid->name, uid->len);
 510     }
 511
 512   return uid->namehash;
 513 }
 514
 515
 516 /*
 517  * Return the number of bits used in PK.
 518  */
 519 unsigned int
 520 nbits_from_pk (PKT_public_key *pk)
 521 {
 522     return pubkey_nbits (pk->pubkey_algo, pk->pkey);
 523 }
 524
 525
 526 static const char *
 527 mk_datestr (char *buffer, time_t atime)
 528 {
 529   struct tm *tp;
 530
 531   if (IS_INVALID_TIME_T (atime))
 532     strcpy (buffer, "????" "-??" "-??"); /* Mark this as invalid. */
 533   else
 534     {
 535       tp = gmtime (&atime);
 536       sprintf (buffer,"%04d-%02d-%02d",
 537                1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
 538     }
 539   return buffer;
 540 }
 541
 542
 543 /*
 544  * return a string with the creation date of the pk
 545  * Note: this is alloced in a static buffer.
 546  *    Format is: yyyy-mm-dd
 547  */
 548 const char *
 549 datestr_from_pk (PKT_public_key *pk)
 550 {
 551   static char buffer[11+5];
 552   time_t atime = pk->timestamp;
 553
 554   return mk_datestr (buffer, atime);
 555 }
 556
 557
 558 const char *
 559 datestr_from_sig (PKT_signature *sig )
 560 {
 561   static char buffer[11+5];
 562   time_t atime = sig->timestamp;
 563
 564   return mk_datestr (buffer, atime);
 565 }
 566
 567
 568 const char *
 569 expirestr_from_pk (PKT_public_key *pk)
 570 {
 571   static char buffer[11+5];
 572   time_t atime;
 573
 574   if (!pk->expiredate)
 575     return _("never     ");
 576   atime = pk->expiredate;
 577   return mk_datestr (buffer, atime);
 578 }
 579
 580
 581 const char *
 582 expirestr_from_sig (PKT_signature *sig)
 583 {
 584   static char buffer[11+5];
 585   time_t atime;
 586
 587   if (!sig->expiredate)
 588     return _("never     ");
 589   atime=sig->expiredate;
 590   return mk_datestr (buffer, atime);
 591 }
 592
 593
 594 const char *
 595 revokestr_from_pk( PKT_public_key *pk )
 596 {
 597   static char buffer[11+5];
 598   time_t atime;
 599
 600   if(!pk->revoked.date)
 601     return _("never     ");
 602   atime=pk->revoked.date;
 603   return mk_datestr (buffer, atime);
 604 }
 605
 606
 607 const char *
 608 usagestr_from_pk (PKT_public_key *pk, int fill)
 609 {
 610   static char buffer[10];
 611   int i = 0;
 612   unsigned int use = pk->pubkey_usage;
 613
 614   if ( use & PUBKEY_USAGE_SIG )
 615     buffer[i++] = 'S';
 616
 617   if ( use & PUBKEY_USAGE_CERT )
 618     buffer[i++] = 'C';
 619
 620   if ( use & PUBKEY_USAGE_ENC )
 621     buffer[i++] = 'E';
 622
 623   if ( (use & PUBKEY_USAGE_AUTH) )
 624     buffer[i++] = 'A';
 625
 626   while (fill && i < 4)
 627     buffer[i++] = ' ';
 628
 629   buffer[i] = 0;
 630   return buffer;
 631 }
 632
 633
 634 const char *
 635 colon_strtime (u32 t)
 636 {
 637   static char buf[20];
 638
 639   if (!t)
 640     return "";
 641   snprintf (buf, sizeof buf, "%lu", (ulong)t);
 642   return buf;
 643 }
 644
 645 const char *
 646 colon_datestr_from_pk (PKT_public_key *pk)
 647 {
 648   static char buf[20];
 649
 650   snprintf (buf, sizeof buf, "%lu", (ulong)pk->timestamp);
 651   return buf;
 652 }
 653
 654
 655 const char *
 656 colon_datestr_from_sig (PKT_signature *sig)
 657 {
 658   static char buf[20];
 659
 660   snprintf (buf, sizeof buf, "%lu", (ulong)sig->timestamp);
 661   return buf;
 662 }
 663
 664 const char *
 665 colon_expirestr_from_sig (PKT_signature *sig)
 666 {
 667   static char buf[20];
 668
 669   if (!sig->expiredate)
 670     return "";
 671
 672   snprintf (buf, sizeof buf,"%lu", (ulong)sig->expiredate);
 673   return buf;
 674 }
 675
 676
 677 /*
 678  * Return a byte array with the fingerprint for the given PK/SK
 679  * The length of the array is returned in ret_len. Caller must free
 680  * the array or provide an array of length MAX_FINGERPRINT_LEN.
 681  */
 682 byte *
 683 fingerprint_from_pk (PKT_public_key *pk, byte *array, size_t *ret_len)
 684 {
 685   const byte *dp;
 686   size_t len;
 687   gcry_md_hd_t md;
 688
 689   md = do_fingerprint_md(pk);
 690   dp = gcry_md_read( md, 0 );
 691   len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
 692   assert( len <= MAX_FINGERPRINT_LEN );
 693   if (!array)
 694     array = xmalloc ( len );
 695   memcpy (array, dp, len );
 696   pk->keyid[0] = buf32_to_u32 (dp+12);
 697   pk->keyid[1] = buf32_to_u32 (dp+16);
 698   gcry_md_close( md);
 699
 700   if (ret_len)
 701     *ret_len = len;
 702   return array;
 703 }
 704
 705
 706 /* Return an allocated buffer with the fingerprint of PK formatted as
 707    a plain hexstring.  */
 708 char *
 709 hexfingerprint (PKT_public_key *pk)
 710 {
 711   unsigned char fpr[MAX_FINGERPRINT_LEN];
 712   size_t len;
 713   char *result;
 714
 715   fingerprint_from_pk (pk, fpr, &len);
 716   result = xmalloc (2 * len + 1);
 717   bin2hex (fpr, len, result);
 718   return result;
 719 }
 720
 721
 722 \f
 723 /* Return the so called KEYGRIP which is the SHA-1 hash of the public
 724    key parameters expressed as an canoncial encoded S-Exp.  ARRAY must
 725    be 20 bytes long.  Returns 0 on sucess or an error code.  */
 726 gpg_error_t
 727 keygrip_from_pk (PKT_public_key *pk, unsigned char *array)
 728 {
 729   gpg_error_t err;
 730   gcry_sexp_t s_pkey;
 731
 732   if (DBG_PACKET)
 733     log_debug ("get_keygrip for public key\n");
 734
 735   switch (pk->pubkey_algo)
 736     {
 737     case GCRY_PK_DSA:
 738       err = gcry_sexp_build (&s_pkey, NULL,
 739                              "(public-key(dsa(p%m)(q%m)(g%m)(y%m)))",
 740                              pk->pkey[0], pk->pkey[1],
 741                              pk->pkey[2], pk->pkey[3]);
 742       break;
 743
 744     case GCRY_PK_ELG:
 745     case GCRY_PK_ELG_E:
 746       err = gcry_sexp_build (&s_pkey, NULL,
 747                              "(public-key(elg(p%m)(g%m)(y%m)))",
 748                              pk->pkey[0], pk->pkey[1], pk->pkey[2]);
 749       break;
 750
 751     case GCRY_PK_RSA:
 752     case GCRY_PK_RSA_S:
 753     case GCRY_PK_RSA_E:
 754       err = gcry_sexp_build (&s_pkey, NULL,
 755                              "(public-key(rsa(n%m)(e%m)))",
 756                              pk->pkey[0], pk->pkey[1]);
 757       break;
 758
 759     case PUBKEY_ALGO_EDDSA:
 760     case PUBKEY_ALGO_ECDSA:
 761     case PUBKEY_ALGO_ECDH:
 762       {
 763         char *curve = openpgp_oid_to_str (pk->pkey[0]);
 764         if (!curve)
 765           err = gpg_error_from_syserror ();
 766         else
 767           {
 768             err = gcry_sexp_build (&s_pkey, NULL,
 769                                    pk->pubkey_algo == PUBKEY_ALGO_EDDSA ?
 770                                    "(public-key(ecc(curve%s)(flags eddsa)(q%m)))"
 771                                    : "(public-key(ecc(curve%s)(q%m)))",
 772                                    curve, pk->pkey[1]);
 773             xfree (curve);
 774           }
 775       }
 776       break;
 777
 778     default:
 779       err = gpg_error (GPG_ERR_PUBKEY_ALGO);
 780       break;
 781     }
 782
 783   if (err)
 784     return err;
 785
 786   if (!gcry_pk_get_keygrip (s_pkey, array))
 787     {
 788       log_info ("error computing keygrip\n");
 789       memset (array, 0, 20);
 790       err = gpg_error (GPG_ERR_GENERAL);
 791     }
 792   else
 793     {
 794       if (DBG_PACKET)
 795         log_printhex ("keygrip=", array, 20);
 796       /* FIXME: Save the keygrip in PK.  */
 797     }
 798   gcry_sexp_release (s_pkey);
 799
 800   return 0;
 801 }
 802
 803
 804 /* Store an allocated buffer with the keygrip of PK encoded as a
 805    hexstring at r_GRIP.  Returns 0 on success.  */
 806 gpg_error_t
 807 hexkeygrip_from_pk (PKT_public_key *pk, char **r_grip)
 808 {
 809   gpg_error_t err;
 810   unsigned char grip[20];
 811
 812   *r_grip = NULL;
 813   err = keygrip_from_pk (pk, grip);
 814   if (!err)
 815     {
 816       char * buf = xtrymalloc (20*2+1);
 817       if (!buf)
 818         err = gpg_error_from_syserror ();
 819       else
 820         {
 821           bin2hex (grip, 20, buf);
 822           *r_grip = buf;
 823         }
 824     }
 825   return err;
 826 }