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