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