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