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