Updated FSF street address and preparations for a release candidate.
[gnupg.git] / g10 / keyid.c
1 /* keyid.c - key ID and fingerprint handling
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003,
3  *               2004 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 2 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, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <time.h>
29 #include <assert.h>
30 #include "util.h"
31 #include "main.h"
32 #include "packet.h"
33 #include "options.h"
34 #include "mpi.h"
35 #include "keydb.h"
36 #include "i18n.h"
37
38 int
39 pubkey_letter( int algo )
40 {
41     switch( algo ) {
42       case PUBKEY_ALGO_RSA:     return 'R' ;
43       case PUBKEY_ALGO_RSA_E:   return 'r' ;
44       case PUBKEY_ALGO_RSA_S:   return 's' ;
45       case PUBKEY_ALGO_ELGAMAL_E: return 'g';
46       case PUBKEY_ALGO_ELGAMAL: return 'G' ;
47       case PUBKEY_ALGO_DSA:     return 'D' ;
48       default: return '?';
49     }
50 }
51
52 /* This function is useful for v4 fingerprints and v3 or v4 key
53    signing. */
54 void
55 hash_public_key( MD_HANDLE md, PKT_public_key *pk )
56 {
57   unsigned n=6;
58   unsigned nb[PUBKEY_MAX_NPKEY];
59   unsigned nn[PUBKEY_MAX_NPKEY];
60   byte *pp[PUBKEY_MAX_NPKEY];
61   int i;
62   int npkey = pubkey_get_npkey( pk->pubkey_algo );
63
64   /* Two extra bytes for the expiration date in v3 */
65   if(pk->version<4)
66     n+=2;
67
68   if(npkey==0 && pk->pkey[0] && mpi_is_opaque(pk->pkey[0]))
69     {
70       pp[0]=mpi_get_opaque(pk->pkey[0],&nn[0]);
71       n+=nn[0];
72     }
73   else
74     for(i=0; i < npkey; i++ )
75       {
76         nb[i] = mpi_get_nbits(pk->pkey[i]);
77         pp[i] = mpi_get_buffer( pk->pkey[i], nn+i, NULL );
78         n += 2 + nn[i];
79       }
80
81   md_putc( md, 0x99 );     /* ctb */
82   /* What does it mean if n is greater than than 0xFFFF ? */
83   md_putc( md, n >> 8 );   /* 2 byte length header */
84   md_putc( md, n );
85   md_putc( md, pk->version );
86
87   md_putc( md, pk->timestamp >> 24 );
88   md_putc( md, pk->timestamp >> 16 );
89   md_putc( md, pk->timestamp >>  8 );
90   md_putc( md, pk->timestamp       );
91
92   if(pk->version<4)
93     {
94       u16 days=0;
95       if(pk->expiredate)
96         days=(u16)((pk->expiredate - pk->timestamp) / 86400L);
97  
98       md_putc( md, days >> 8 );
99       md_putc( md, days );
100     }
101
102   md_putc( md, pk->pubkey_algo );
103
104   if(npkey==0 && pk->pkey[0] && mpi_is_opaque(pk->pkey[0]))
105     md_write(md,pp[0],nn[0]);
106   else
107     for(i=0; i < npkey; i++ )
108       {
109         md_putc( md, nb[i]>>8);
110         md_putc( md, nb[i] );
111         md_write( md, pp[i], nn[i] );
112         m_free(pp[i]);
113       }
114 }
115
116 static MD_HANDLE
117 do_fingerprint_md( PKT_public_key *pk )
118 {
119   MD_HANDLE md;
120
121   md = md_open( DIGEST_ALGO_SHA1, 0);
122   hash_public_key(md,pk);
123   md_final( md );
124
125   return md;
126 }
127
128 static MD_HANDLE
129 do_fingerprint_md_sk( PKT_secret_key *sk )
130 {
131     PKT_public_key pk;
132     int npkey = pubkey_get_npkey( sk->pubkey_algo ); /* npkey is correct! */
133     int i;
134
135     if(npkey==0)
136       return NULL;
137
138     pk.pubkey_algo = sk->pubkey_algo;
139     pk.version     = sk->version;
140     pk.timestamp = sk->timestamp;
141     pk.expiredate = sk->expiredate;
142     pk.pubkey_algo = sk->pubkey_algo;
143     for( i=0; i < npkey; i++ )
144       pk.pkey[i] = sk->skey[i];
145     return do_fingerprint_md( &pk );
146 }
147
148 size_t
149 keystrlen(void)
150 {
151   switch(opt.keyid_format)
152     {
153     case KF_SHORT:
154       return 8;
155
156     case KF_LONG:
157       return 16;
158
159     case KF_0xSHORT:
160       return 10;
161
162     case KF_0xLONG:
163       return 18;
164
165     default:
166       BUG();
167     }
168 }
169
170 const char *
171 keystr(u32 *keyid)
172 {  
173   static char keyid_str[19];
174
175   switch(opt.keyid_format)
176     {
177     case KF_SHORT:
178       sprintf(keyid_str,"%08lX",(ulong)keyid[1]);
179       break;
180
181     case KF_LONG:
182       if(keyid[0])
183         sprintf(keyid_str,"%08lX%08lX",(ulong)keyid[0],(ulong)keyid[1]);
184       else
185         sprintf(keyid_str,"%08lX",(ulong)keyid[1]);
186       break;
187
188     case KF_0xSHORT:
189       sprintf(keyid_str,"0x%08lX",(ulong)keyid[1]);
190       break;
191
192     case KF_0xLONG:
193       if(keyid[0])
194         sprintf(keyid_str,"0x%08lX%08lX",(ulong)keyid[0],(ulong)keyid[1]);
195       else
196         sprintf(keyid_str,"0x%08lX",(ulong)keyid[1]);
197       break;
198
199     default:
200       BUG();
201     }
202
203   return keyid_str;
204 }
205
206 const char *
207 keystr_from_pk(PKT_public_key *pk)
208 {
209   keyid_from_pk(pk,NULL);
210
211   return keystr(pk->keyid);
212 }
213
214 const char *
215 keystr_from_sk(PKT_secret_key *sk)
216 {
217   keyid_from_sk(sk,NULL);
218
219   return keystr(sk->keyid);
220 }
221
222 const char *
223 keystr_from_desc(KEYDB_SEARCH_DESC *desc)
224 {
225   switch(desc->mode)
226     {
227     case KEYDB_SEARCH_MODE_LONG_KID:
228     case KEYDB_SEARCH_MODE_SHORT_KID:
229       return keystr(desc->u.kid);
230
231     case KEYDB_SEARCH_MODE_FPR20:
232       {
233         u32 keyid[2];
234
235         keyid[0] = (unsigned char)desc->u.fpr[12] << 24
236           | (unsigned char)desc->u.fpr[13] << 16
237           | (unsigned char)desc->u.fpr[14] << 8
238           | (unsigned char)desc->u.fpr[15] ;
239         keyid[1] = (unsigned char)desc->u.fpr[16] << 24
240           | (unsigned char)desc->u.fpr[17] << 16
241           | (unsigned char)desc->u.fpr[18] << 8
242           | (unsigned char)desc->u.fpr[19] ;
243
244         return keystr(keyid);
245       }
246
247     case KEYDB_SEARCH_MODE_FPR16:
248       return "?v3 fpr?";
249
250     default:
251       BUG();
252     }
253 }
254
255 /****************
256  * Get the keyid from the secret key and put it into keyid
257  * if this is not NULL. Return the 32 low bits of the keyid.
258  */
259 u32
260 keyid_from_sk( PKT_secret_key *sk, u32 *keyid )
261 {
262   u32 lowbits;
263   u32 dummy_keyid[2];
264
265   if( !keyid )
266     keyid = dummy_keyid;
267
268   if( sk->keyid[0] || sk->keyid[1] )
269     {
270       keyid[0] = sk->keyid[0];
271       keyid[1] = sk->keyid[1];
272       lowbits = keyid[1];
273     }
274   else if( sk->version < 4 )
275     {
276       if( is_RSA(sk->pubkey_algo) )
277         {
278           lowbits = pubkey_get_npkey(sk->pubkey_algo) ?
279             mpi_get_keyid( sk->skey[0], keyid ) : 0; /* take n */
280           sk->keyid[0]=keyid[0];
281           sk->keyid[1]=keyid[1];
282         }
283       else
284         sk->keyid[0]=sk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
285     }
286   else
287     {
288       const byte *dp;
289       MD_HANDLE md;
290       md = do_fingerprint_md_sk(sk);
291       if(md)
292         {
293           dp = md_read( md, 0 );
294           keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
295           keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
296           lowbits = keyid[1];
297           md_close(md);
298           sk->keyid[0] = keyid[0];
299           sk->keyid[1] = keyid[1];
300         }
301       else
302         sk->keyid[0]=sk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
303     }
304
305   return lowbits;
306 }
307
308
309 /****************
310  * Get the keyid from the public key and put it into keyid
311  * if this is not NULL. Return the 32 low bits of the keyid.
312  */
313 u32
314 keyid_from_pk( PKT_public_key *pk, u32 *keyid )
315 {
316   u32 lowbits;
317   u32 dummy_keyid[2];
318
319   if( !keyid )
320     keyid = dummy_keyid;
321
322   if( pk->keyid[0] || pk->keyid[1] )
323     {
324       keyid[0] = pk->keyid[0];
325       keyid[1] = pk->keyid[1];
326       lowbits = keyid[1];
327     }
328   else if( pk->version < 4 )
329     {
330       if( is_RSA(pk->pubkey_algo) )
331         {
332           lowbits = pubkey_get_npkey(pk->pubkey_algo) ?
333             mpi_get_keyid( pk->pkey[0], keyid ) : 0 ; /* from n */
334           pk->keyid[0] = keyid[0];
335           pk->keyid[1] = keyid[1];
336         }
337       else
338         pk->keyid[0]=pk->keyid[1]=keyid[0]=keyid[1]=lowbits=0xFFFFFFFF;
339     }
340   else
341     {
342       const byte *dp;
343       MD_HANDLE md;
344       md = do_fingerprint_md(pk);
345       if(md)
346         {
347           dp = md_read( md, 0 );
348           keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
349           keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
350           lowbits = keyid[1];
351           md_close(md);
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
359   return lowbits;
360 }
361
362
363 /****************
364  * Get the keyid from the fingerprint.  This function is simple for most
365  * keys, but has to do a keylookup for old stayle keys.
366  */
367 u32
368 keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
369 {
370     u32 dummy_keyid[2];
371
372     if( !keyid )
373         keyid = dummy_keyid;
374
375     if( fprint_len != 20 ) {
376         /* This is special as we have to lookup the key first */
377         PKT_public_key pk;
378         int rc;
379
380         memset( &pk, 0, sizeof pk );
381         rc = get_pubkey_byfprint( &pk, fprint, fprint_len );
382         if( rc ) {
383             log_error("Oops: keyid_from_fingerprint: no pubkey\n");
384             keyid[0] = 0;
385             keyid[1] = 0;
386         }
387         else
388             keyid_from_pk( &pk, keyid );
389     }
390     else {
391         const byte *dp = fprint;
392         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
393         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
394     }
395
396     return keyid[1];
397 }
398
399
400 u32
401 keyid_from_sig( PKT_signature *sig, u32 *keyid )
402 {
403     if( keyid ) {
404         keyid[0] = sig->keyid[0];
405         keyid[1] = sig->keyid[1];
406     }
407     return sig->keyid[1];
408 }
409
410 byte *
411 namehash_from_uid(PKT_user_id *uid)
412 {
413   if(uid->namehash==NULL)
414     {
415       uid->namehash=m_alloc(20);
416
417       if(uid->attrib_data)
418         rmd160_hash_buffer(uid->namehash,uid->attrib_data,uid->attrib_len);
419       else
420         rmd160_hash_buffer(uid->namehash,uid->name,uid->len);
421     }
422
423   return uid->namehash;
424 }
425
426 /****************
427  * return the number of bits used in the pk
428  */
429 unsigned
430 nbits_from_pk( PKT_public_key *pk )
431 {
432     return pubkey_nbits( pk->pubkey_algo, pk->pkey );
433 }
434
435 /****************
436  * return the number of bits used in the sk
437  */
438 unsigned
439 nbits_from_sk( PKT_secret_key *sk )
440 {
441     return pubkey_nbits( sk->pubkey_algo, sk->skey );
442 }
443
444 static const char *
445 mk_datestr (char *buffer, time_t atime)
446 {
447     struct tm *tp;
448
449     if ( atime < 0 ) /* 32 bit time_t and after 2038-01-19 */
450         strcpy (buffer, "????" "-??" "-??"); /* mark this as invalid */
451     else {
452         tp = gmtime (&atime);
453         sprintf (buffer,"%04d-%02d-%02d",
454                  1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
455     }
456     return buffer;
457 }
458
459 /****************
460  * return a string with the creation date of the pk
461  * Note: this is alloced in a static buffer.
462  *    Format is: yyyy-mm-dd
463  */
464 const char *
465 datestr_from_pk( PKT_public_key *pk )
466 {
467     static char buffer[11+5];
468     time_t atime = pk->timestamp;
469
470     return mk_datestr (buffer, atime);
471 }
472
473 const char *
474 datestr_from_sk( PKT_secret_key *sk )
475 {
476     static char buffer[11+5];
477     time_t atime = sk->timestamp;
478
479     return mk_datestr (buffer, atime);
480 }
481
482 const char *
483 datestr_from_sig( PKT_signature *sig )
484 {
485     static char buffer[11+5];
486     time_t atime = sig->timestamp;
487
488     return mk_datestr (buffer, atime);
489 }
490
491 const char *
492 expirestr_from_pk( PKT_public_key *pk )
493 {
494     static char buffer[11+5];
495     time_t atime;
496
497     if( !pk->expiredate )
498         return _("never     ");
499     atime = pk->expiredate;
500     return mk_datestr (buffer, atime);
501 }
502
503 const char *
504 expirestr_from_sk( PKT_secret_key *sk )
505 {
506     static char buffer[11+5];
507     time_t atime;
508
509     if( !sk->expiredate )
510         return _("never     ");
511     atime = sk->expiredate;
512     return mk_datestr (buffer, atime);
513 }
514
515 const char *
516 expirestr_from_sig( PKT_signature *sig )
517 {
518     static char buffer[11+5];
519     time_t atime;
520
521     if(!sig->expiredate)
522       return _("never     ");
523     atime=sig->expiredate;
524     return mk_datestr (buffer, atime);
525 }
526
527 const char *
528 revokestr_from_pk( PKT_public_key *pk )
529 {
530     static char buffer[11+5];
531     time_t atime;
532
533     if(!pk->revoked.date)
534       return _("never     ");
535     atime=pk->revoked.date;
536     return mk_datestr (buffer, atime);
537 }
538
539
540 const char *
541 usagestr_from_pk( PKT_public_key *pk )
542 {
543   static char buffer[10];
544   int i = 0;
545   unsigned int use = pk->pubkey_usage;
546     
547   if ( use & PUBKEY_USAGE_SIG )
548     {
549       if (pk->is_primary)
550         buffer[i++] = 'C';
551       buffer[i++] = 'S';
552     }
553
554   if ( use & PUBKEY_USAGE_ENC )
555     buffer[i++] = 'E';
556
557   if ( (use & PUBKEY_USAGE_AUTH) )
558     buffer[i++] = 'A';
559
560   while (i < 4)
561     buffer[i++] = ' ';
562
563   buffer[i] = 0;
564   return buffer;
565 }
566
567
568 const char *
569 colon_strtime (u32 t)
570 {
571     if (!t)
572         return "";
573     if (opt.fixed_list_mode) {
574         static char buf[15];
575         sprintf (buf, "%lu", (ulong)t);
576         return buf;
577     }
578     return strtimestamp(t);
579 }
580
581 const char *
582 colon_datestr_from_pk (PKT_public_key *pk)
583 {
584     if (opt.fixed_list_mode) {
585         static char buf[15];
586         sprintf (buf, "%lu", (ulong)pk->timestamp);
587         return buf;
588     }
589     return datestr_from_pk (pk);
590 }
591
592 const char *
593 colon_datestr_from_sk (PKT_secret_key *sk)
594 {
595     if (opt.fixed_list_mode) {
596         static char buf[15];
597         sprintf (buf, "%lu", (ulong)sk->timestamp);
598         return buf;
599     }
600     return datestr_from_sk (sk);
601 }
602
603 const char *
604 colon_datestr_from_sig (PKT_signature *sig)
605 {
606     if (opt.fixed_list_mode) {
607         static char buf[15];
608         sprintf (buf, "%lu", (ulong)sig->timestamp);
609         return buf;
610     }
611     return datestr_from_sig (sig);
612 }
613
614 const char *
615 colon_expirestr_from_sig (PKT_signature *sig)
616 {
617     if(!sig->expiredate)
618         return "";
619     if (opt.fixed_list_mode) {
620         static char buf[15];
621         sprintf (buf, "%lu", (ulong)sig->expiredate);
622         return buf;
623     }
624     return expirestr_from_sig (sig);
625 }
626
627
628 /**************** .
629  * Return a byte array with the fingerprint for the given PK/SK
630  * The length of the array is returned in ret_len. Caller must free
631  * the array or provide an array of length MAX_FINGERPRINT_LEN.
632  */
633
634 byte *
635 fingerprint_from_pk( PKT_public_key *pk, byte *array, size_t *ret_len )
636 {
637     byte *p, *buf;
638     const byte *dp;
639     size_t len;
640     unsigned int n;
641
642     if( pk->version < 4 )
643       {
644         if( is_RSA(pk->pubkey_algo) )
645           {
646             /* RSA in version 3 packets is special */
647             MD_HANDLE md;
648
649             md = md_open( DIGEST_ALGO_MD5, 0);
650             if( pubkey_get_npkey( pk->pubkey_algo ) > 1 ) {
651               p = buf = mpi_get_buffer( pk->pkey[0], &n, NULL );
652               md_write( md, p, n );
653               m_free(buf);
654               p = buf = mpi_get_buffer( pk->pkey[1], &n, NULL );
655               md_write( md, p, n );
656               m_free(buf);
657             }
658             md_final(md);
659             if( !array )
660               array = m_alloc( 16 );
661             len = 16;
662             memcpy(array, md_read(md, DIGEST_ALGO_MD5), 16 );
663             md_close(md);
664           }
665         else
666           {
667             if(!array)
668               array=m_alloc(16);
669             len=16;
670             memset(array,0,16);
671           }
672       }
673     else {
674         MD_HANDLE md;
675         md = do_fingerprint_md(pk);
676         dp = md_read( md, 0 );
677         len = md_digest_length( md_get_algo( md ) );
678         assert( len <= MAX_FINGERPRINT_LEN );
679         if( !array )
680             array = m_alloc( len );
681         memcpy(array, dp, len );
682         pk->keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
683         pk->keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
684         md_close(md);
685     }
686
687     *ret_len = len;
688     return array;
689 }
690
691 byte *
692 fingerprint_from_sk( PKT_secret_key *sk, byte *array, size_t *ret_len )
693 {
694     byte *p, *buf;
695     const char *dp;
696     size_t len;
697     unsigned n;
698
699     if( sk->version < 4 )
700       {
701         if( is_RSA(sk->pubkey_algo) )
702           {
703             /* RSA in version 3 packets is special */
704             MD_HANDLE md;
705
706             md = md_open( DIGEST_ALGO_MD5, 0);
707             if( pubkey_get_npkey( sk->pubkey_algo ) > 1 ) {
708               p = buf = mpi_get_buffer( sk->skey[0], &n, NULL );
709               md_write( md, p, n );
710               m_free(buf);
711               p = buf = mpi_get_buffer( sk->skey[1], &n, NULL );
712               md_write( md, p, n );
713               m_free(buf);
714             }
715             md_final(md);
716             if( !array )
717               array = m_alloc( 16 );
718             len = 16;
719             memcpy(array, md_read(md, DIGEST_ALGO_MD5), 16 );
720             md_close(md);
721           }
722         else
723           {
724             if(!array)
725               array=m_alloc(16);
726             len=16;
727             memset(array,0,16);
728           }
729       }
730     else {
731         MD_HANDLE md;
732         md = do_fingerprint_md_sk(sk);
733         if(md)
734           {
735             dp = md_read( md, 0 );
736             len = md_digest_length( md_get_algo( md ) );
737             assert( len <= MAX_FINGERPRINT_LEN );
738             if( !array )
739               array = m_alloc( len );
740             memcpy(array, dp, len );
741             md_close(md);
742           }
743         else
744           {
745             len=MAX_FINGERPRINT_LEN;
746             if(!array)
747               array=m_alloc(len);
748             memset(array,0,len);
749           }
750     }
751
752     *ret_len = len;
753     return array;
754 }