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