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