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