* app-openpgp.c (store_fpr): Fixed fingerprint calculation.
[gnupg.git] / g10 / keyid.c
1 /* keyid.c - key ID and fingerprint handling
2  * Copyright (C) 1998, 1999, 2000, 2001, 2003 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
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 "mpi.h"
35 #include "keydb.h"
36 #include "i18n.h"
37
38
39 int
40 pubkey_letter( int algo )
41 {
42     switch( algo ) {
43       case PUBKEY_ALGO_RSA:     return 'R' ;
44       case PUBKEY_ALGO_RSA_E:   return 'r' ;
45       case PUBKEY_ALGO_RSA_S:   return 's' ;
46       case PUBKEY_ALGO_ELGAMAL_E: return 'g';
47       case PUBKEY_ALGO_ELGAMAL: return 'G' ;
48       case PUBKEY_ALGO_DSA:     return 'D' ;
49       default: return '?';
50     }
51 }
52
53 static gcry_md_hd_t
54 do_fingerprint_md( PKT_public_key *pk )
55 {
56     gcry_md_hd_t md;
57     unsigned int n;
58     unsigned int nn[PUBKEY_MAX_NPKEY];
59     byte *pp[PUBKEY_MAX_NPKEY];
60     int i;
61     int npkey = pubkey_get_npkey( pk->pubkey_algo );
62
63     gcry_md_open (&md, pk->version < 4 ? DIGEST_ALGO_RMD160
64                                        : DIGEST_ALGO_SHA1, 0);
65     n = pk->version < 4 ? 8 : 6;
66     for(i=0; i < npkey; i++ ) {
67         size_t nbytes;
68
69         if (gcry_mpi_print( GCRYMPI_FMT_PGP, NULL, &nbytes, pk->pkey[i] ))
70           BUG ();
71         /* fixme: we should try to allocate a buffer on the stack */
72         pp[i] = xmalloc(nbytes);
73         if (gcry_mpi_print ( GCRYMPI_FMT_PGP, pp[i], &nbytes, pk->pkey[i] ))
74           BUG ();
75         nn[i] = nbytes;
76         n += nn[i];
77     }
78
79     gcry_md_putc ( md, 0x99 );     /* ctb */
80     gcry_md_putc ( md, n >> 8 );   /* 2 byte length header */
81     gcry_md_putc ( md, n );
82     if( pk->version < 4 )
83         gcry_md_putc ( md, 3 );
84     else
85         gcry_md_putc ( md, 4 );
86
87     {   u32 a = pk->timestamp;
88         gcry_md_putc ( md, a >> 24 );
89         gcry_md_putc ( md, a >> 16 );
90         gcry_md_putc ( md, a >>  8 );
91         gcry_md_putc ( md, a         );
92     }
93     if( pk->version < 4 ) {
94         u16 a;
95
96         if( pk->expiredate )
97             a = (u16)((pk->expiredate - pk->timestamp) / 86400L);
98         else
99             a = 0;
100         gcry_md_putc ( md, a >> 8 );
101         gcry_md_putc ( md, a        );
102     }
103     gcry_md_putc ( md, pk->pubkey_algo );
104     for(i=0; i < npkey; i++ ) {
105         gcry_md_write( md, pp[i], nn[i] );
106         xfree (pp[i]);
107     }
108     gcry_md_final ( md );
109
110     return md;
111 }
112
113 static gcry_md_hd_t
114 do_fingerprint_md_sk( PKT_secret_key *sk )
115 {
116     PKT_public_key pk;
117     int npkey = pubkey_get_npkey( sk->pubkey_algo ); /* npkey is correct! */
118     int i;
119
120     pk.pubkey_algo = sk->pubkey_algo;
121     pk.version     = sk->version;
122     pk.timestamp = sk->timestamp;
123     pk.expiredate = sk->expiredate;
124     pk.pubkey_algo = sk->pubkey_algo;
125     for( i=0; i < npkey; i++ )
126         pk.pkey[i] = sk->skey[i];
127     return do_fingerprint_md( &pk );
128 }
129
130
131 u32
132 v3_keyid (gcry_mpi_t a, u32 *ki)
133 {
134   byte *buffer;
135   size_t nbytes;
136
137   if (gcry_mpi_print (GCRYMPI_FMT_USG, NULL, &nbytes, a ))
138     BUG ();
139   /* fixme: allocate it on the stack */
140   buffer = xmalloc (nbytes);
141   if (gcry_mpi_print( GCRYMPI_FMT_USG, buffer, &nbytes, a ))
142     BUG ();
143   if (nbytes < 8) /* oops */
144     ki[0] = ki[1] = 0;
145   else 
146     {
147       memcpy (ki+0, buffer+nbytes-8, 4);
148       memcpy (ki+1, buffer+nbytes-4, 4);
149     }
150   xfree (buffer);
151   return ki[1];
152 }
153
154
155
156 /****************
157  * Get the keyid from the secret key and put it into keyid
158  * if this is not NULL. Return the 32 low bits of the keyid.
159  */
160 u32
161 keyid_from_sk( PKT_secret_key *sk, u32 *keyid )
162 {
163     u32 lowbits;
164     u32 dummy_keyid[2];
165
166     if( !keyid )
167         keyid = dummy_keyid;
168
169     if( sk->version < 4 && is_RSA(sk->pubkey_algo) ) {
170         keyid[0] = keyid[1] = 0;
171         lowbits = pubkey_get_npkey(sk->pubkey_algo) ?
172                      v3_keyid (sk->skey[0], keyid) : 0; 
173     }
174     else {
175         const byte *dp;
176         gcry_md_hd_t md;
177         md = do_fingerprint_md_sk(sk);
178         dp = gcry_md_read ( md, 0 );
179         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
180         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
181         lowbits = keyid[1];
182         gcry_md_close (md);
183     }
184
185     return lowbits;
186 }
187
188
189 /****************
190  * Get the keyid from the public key and put it into keyid
191  * if this is not NULL. Return the 32 low bits of the keyid.
192  */
193 u32
194 keyid_from_pk( PKT_public_key *pk, u32 *keyid )
195 {
196     u32 lowbits;
197     u32 dummy_keyid[2];
198
199     if( !keyid )
200         keyid = dummy_keyid;
201
202     if( pk->keyid[0] || pk->keyid[1] ) {
203         keyid[0] = pk->keyid[0];
204         keyid[1] = pk->keyid[1];
205         lowbits = keyid[1];
206     }
207     else if( pk->version < 4 && is_RSA(pk->pubkey_algo) ) {
208         keyid[0] = keyid[1] = 0;
209         lowbits = pubkey_get_npkey(pk->pubkey_algo) ?
210                      v3_keyid (pk->pkey[0], keyid) : 0 ; 
211         pk->keyid[0] = keyid[0];
212         pk->keyid[1] = keyid[1];
213     }
214     else {
215         const byte *dp;
216         gcry_md_hd_t md;
217         md = do_fingerprint_md(pk);
218         dp = gcry_md_read ( md, 0 );
219         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
220         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
221         lowbits = keyid[1];
222         gcry_md_close (md);
223         pk->keyid[0] = keyid[0];
224         pk->keyid[1] = keyid[1];
225     }
226
227     return lowbits;
228 }
229
230
231 /****************
232  * Get the keyid from the fingerprint.  This function is simple for most
233  * keys, but has to do a keylookup for old stayle keys.
234  */
235 u32
236 keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
237 {
238     u32 dummy_keyid[2];
239
240     if( !keyid )
241         keyid = dummy_keyid;
242
243     if( fprint_len != 20 ) {
244         /* This is special as we have to lookup the key first */
245         PKT_public_key pk;
246         int rc;
247
248         memset( &pk, 0, sizeof pk );
249         rc = get_pubkey_byfprint( &pk, fprint, fprint_len );
250         if( rc ) {
251             log_error("Oops: keyid_from_fingerprint: no pubkey\n");
252             keyid[0] = 0;
253             keyid[1] = 0;
254         }
255         else
256             keyid_from_pk( &pk, keyid );
257     }
258     else {
259         const byte *dp = fprint;
260         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
261         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
262     }
263
264     return keyid[1];
265 }
266
267
268 u32
269 keyid_from_sig( PKT_signature *sig, u32 *keyid )
270 {
271     if( keyid ) {
272         keyid[0] = sig->keyid[0];
273         keyid[1] = sig->keyid[1];
274     }
275     return sig->keyid[1];
276 }
277
278 byte *
279 namehash_from_uid(PKT_user_id *uid)
280 {
281   if(uid->namehash==NULL)
282     {
283       uid->namehash=xmalloc (20);
284
285       if(uid->attrib_data)
286         gcry_md_hash_buffer (GCRY_MD_RMD160, uid->namehash,
287                              uid->attrib_data,uid->attrib_len);
288       else
289         gcry_md_hash_buffer (GCRY_MD_RMD160, uid->namehash,
290                              uid->name,uid->len);
291     }
292
293   return uid->namehash;
294 }
295
296 /****************
297  * return the number of bits used in the pk
298  */
299 unsigned
300 nbits_from_pk( PKT_public_key *pk )
301 {
302     return pubkey_nbits( pk->pubkey_algo, pk->pkey );
303 }
304
305 /****************
306  * return the number of bits used in the sk
307  */
308 unsigned
309 nbits_from_sk( PKT_secret_key *sk )
310 {
311     return pubkey_nbits( sk->pubkey_algo, sk->skey );
312 }
313
314 static const char *
315 mk_datestr (char *buffer, time_t atime)
316 {
317     struct tm *tp;
318
319     if ( atime < 0 ) /* 32 bit time_t and after 2038-01-19 */
320         strcpy (buffer, "????" "-??" "-??"); /* mark this as invalid */
321     else {
322         tp = gmtime (&atime);
323         sprintf (buffer,"%04d-%02d-%02d",
324                  1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
325     }
326     return buffer;
327 }
328
329 /****************
330  * return a string with the creation date of the pk
331  * Note: this is alloced in a static buffer.
332  *    Format is: yyyy-mm-dd
333  */
334 const char *
335 datestr_from_pk( PKT_public_key *pk )
336 {
337     static char buffer[11+5];
338     time_t atime = pk->timestamp;
339
340     return mk_datestr (buffer, atime);
341 }
342
343 const char *
344 datestr_from_sk( PKT_secret_key *sk )
345 {
346     static char buffer[11+5];
347     time_t atime = sk->timestamp;
348
349     return mk_datestr (buffer, atime);
350 }
351
352 const char *
353 datestr_from_sig( PKT_signature *sig )
354 {
355     static char buffer[11+5];
356     time_t atime = sig->timestamp;
357
358     return mk_datestr (buffer, atime);
359 }
360
361 const char *
362 expirestr_from_pk( PKT_public_key *pk )
363 {
364     static char buffer[11+5];
365     time_t atime;
366
367     if( !pk->expiredate )
368         return _("never     ");
369     atime = pk->expiredate;
370     return mk_datestr (buffer, atime);
371 }
372
373 const char *
374 expirestr_from_sk( PKT_secret_key *sk )
375 {
376     static char buffer[11+5];
377     time_t atime;
378
379     if( !sk->expiredate )
380         return _("never     ");
381     atime = sk->expiredate;
382     return mk_datestr (buffer, atime);
383 }
384
385 const char *
386 expirestr_from_sig( PKT_signature *sig )
387 {
388     static char buffer[11+5];
389     time_t atime;
390
391     if(!sig->expiredate)
392       return _("never     ");
393     atime=sig->expiredate;
394     return mk_datestr (buffer, atime);
395 }
396
397 const char *
398 colon_strtime (u32 t)
399 {
400     if (!t)
401         return "";
402     if (opt.fixed_list_mode) {
403         static char buf[15];
404         sprintf (buf, "%lu", (ulong)t);
405         return buf;
406     }
407     return strtimestamp(t);
408 }
409
410 const char *
411 colon_datestr_from_pk (PKT_public_key *pk)
412 {
413     if (opt.fixed_list_mode) {
414         static char buf[15];
415         sprintf (buf, "%lu", (ulong)pk->timestamp);
416         return buf;
417     }
418     return datestr_from_pk (pk);
419 }
420
421 const char *
422 colon_datestr_from_sk (PKT_secret_key *sk)
423 {
424     if (opt.fixed_list_mode) {
425         static char buf[15];
426         sprintf (buf, "%lu", (ulong)sk->timestamp);
427         return buf;
428     }
429     return datestr_from_sk (sk);
430 }
431
432 const char *
433 colon_datestr_from_sig (PKT_signature *sig)
434 {
435     if (opt.fixed_list_mode) {
436         static char buf[15];
437         sprintf (buf, "%lu", (ulong)sig->timestamp);
438         return buf;
439     }
440     return datestr_from_sig (sig);
441 }
442
443 const char *
444 colon_expirestr_from_sig (PKT_signature *sig)
445 {
446     if(!sig->expiredate)
447         return "";
448     if (opt.fixed_list_mode) {
449         static char buf[15];
450         sprintf (buf, "%lu", (ulong)sig->expiredate);
451         return buf;
452     }
453     return expirestr_from_sig (sig);
454 }
455
456
457 /**************** .
458  * Return a byte array with the fingerprint for the given PK/SK
459  * The length of the array is returned in ret_len. Caller must free
460  * the array or provide an array of length MAX_FINGERPRINT_LEN.
461  */
462
463 byte *
464 fingerprint_from_pk( PKT_public_key *pk, byte *array, size_t *ret_len )
465 {
466     byte *buf;
467     const byte *dp;
468     size_t len;
469
470     if( pk->version < 4 && is_RSA(pk->pubkey_algo) ) {
471         /* RSA in version 3 packets is special */
472         gcry_md_hd_t md;
473
474         gcry_md_open (&md, DIGEST_ALGO_MD5, 0);
475         if( pubkey_get_npkey( pk->pubkey_algo ) > 1 ) {
476             size_t nbytes;
477
478             if (gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, pk->pkey[0]))
479               BUG ();
480             /* fixme: allocate it on the stack */
481             buf = xmalloc(nbytes);
482             if (gcry_mpi_print (GCRYMPI_FMT_USG, buf, &nbytes, pk->pkey[0]))
483               BUG ();
484             gcry_md_write (md, buf, nbytes);
485             xfree (buf);
486             if (gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, pk->pkey[1]))
487               BUG ();
488             /* fixme: allocate it on the stack */
489             buf = xmalloc(nbytes);
490             if (gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, pk->pkey[1]))
491               BUG ();
492             gcry_md_write( md, buf, nbytes );
493             xfree(buf);
494         }
495         gcry_md_final (md);
496         if( !array )
497             array = xmalloc ( 16 );
498         len = 16;
499         memcpy(array, gcry_md_read (md, DIGEST_ALGO_MD5), 16 );
500         gcry_md_close (md);
501     }
502     else {
503         gcry_md_hd_t md;
504         md = do_fingerprint_md(pk);
505         dp = gcry_md_read ( md, 0 );
506         len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
507         assert( len <= MAX_FINGERPRINT_LEN );
508         if( !array )
509             array = xmalloc ( len );
510         memcpy(array, dp, len );
511         pk->keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
512         pk->keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
513         gcry_md_close (md);
514     }
515
516     *ret_len = len;
517     return array;
518 }
519
520 byte *
521 fingerprint_from_sk( PKT_secret_key *sk, byte *array, size_t *ret_len )
522 {
523     byte  *buf;
524     const char *dp;
525     size_t len;
526
527     if( sk->version < 4 && is_RSA(sk->pubkey_algo) ) {
528         /* RSA in version 3 packets is special */
529         gcry_md_hd_t md;
530
531         gcry_md_open (&md, DIGEST_ALGO_MD5, 0);
532         if( pubkey_get_npkey( sk->pubkey_algo ) > 1 ) {
533             size_t nbytes;
534
535             if (gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, sk->skey[0]))
536               BUG ();
537             /* fixme: allocate it on the stack */
538             buf = xmalloc(nbytes);
539             if (gcry_mpi_print (GCRYMPI_FMT_USG, buf, &nbytes, sk->skey[0]))
540               BUG ();
541             gcry_md_write (md, buf, nbytes);
542             xfree (buf);
543             if (gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, sk->skey[1]))
544               BUG ();
545             /* fixme: allocate it on the stack */
546             buf = xmalloc(nbytes);
547             if (gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, sk->skey[1]))
548               BUG ();
549             gcry_md_write( md, buf, nbytes );
550             xfree(buf);
551         }
552         gcry_md_final (md);
553         if( !array )
554             array = xmalloc ( 16 );
555         len = 16;
556         memcpy(array, gcry_md_read (md, DIGEST_ALGO_MD5), 16 );
557         gcry_md_close (md);
558     }
559     else {
560         gcry_md_hd_t md;
561
562         md = do_fingerprint_md_sk(sk);
563         dp = gcry_md_read ( md, 0 );
564         len = gcry_md_get_algo_dlen (gcry_md_get_algo (md));
565         assert( len <= MAX_FINGERPRINT_LEN );
566         if( !array )
567             array = xmalloc ( len );
568         memcpy(array, dp, len );
569         gcry_md_close (md);
570     }
571
572     *ret_len = len;
573     return array;
574 }
575
576
577 /* Create a serialno/fpr string from the serial number and the secret
578  * key.  caller must free the returned string.  There is no error
579  * return. */
580 char *
581 serialno_and_fpr_from_sk (const unsigned char *sn, size_t snlen,
582                           PKT_secret_key *sk)
583 {
584   unsigned char fpr[MAX_FINGERPRINT_LEN];
585   size_t fprlen;
586   char *buffer, *p;
587   int i;
588   
589   fingerprint_from_sk (sk, fpr, &fprlen);
590   buffer = p= xmalloc (snlen*2 + 1 + fprlen*2 + 1);
591   for (i=0; i < snlen; i++, p+=2)
592     sprintf (p, "%02X", sn[i]);
593   *p++ = '/';
594   for (i=0; i < fprlen; i++, p+=2)
595     sprintf (p, "%02X", fpr[i]);
596   *p = 0;
597   return buffer;
598 }
599
600
601
602
603
604
605
606