* call-agent.c (start_agent): Make copies of old locales and check
[gnupg.git] / g10 / keyid.c
1 /* keyid.c - jeyid and fingerprint handling
2  *      Copyright (C) 1998, 1999, 2000 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 <gcrypt.h>
30 #include "util.h"
31 #include "main.h"
32 #include "packet.h"
33 #include "options.h"
34 #include "keydb.h"
35 #include "i18n.h"
36
37
38 int
39 pubkey_letter( int algo )
40 {
41     switch( algo ) {
42       case GCRY_PK_RSA: return 'R' ;
43       case GCRY_PK_RSA_E:       return 'r' ;
44       case GCRY_PK_RSA_S:       return 's' ;
45       case GCRY_PK_ELG_E: return 'g';
46       case GCRY_PK_ELG: return 'G' ;
47       case GCRY_PK_DSA: return 'D' ;
48       default: return '?';
49     }
50 }
51
52
53 static GCRY_MD_HD
54 do_fingerprint_md( PKT_public_key *pk )
55 {
56     GCRY_MD_HD md;
57     unsigned int n;
58     unsigned int nn[GNUPG_MAX_NPKEY];
59     byte *pp[GNUPG_MAX_NPKEY];
60     int i;
61     int npkey = pubkey_get_npkey( pk->pubkey_algo );
62
63     md = gcry_md_open( pk->version < 4 ? GCRY_MD_RMD160 : GCRY_MD_SHA1, 0);
64     if( !md )
65         BUG();
66     n = pk->version < 4 ? 8 : 6;
67     for(i=0; i < npkey; i++ ) {
68         int rc;
69         size_t nbytes;
70
71         rc = gcry_mpi_print( GCRYMPI_FMT_PGP, NULL, &nbytes, pk->pkey[i] );
72         assert( !rc );
73         /* fixme: we should try to allocate a buffer on the stack */
74         pp[i] = gcry_xmalloc(nbytes);
75         rc = gcry_mpi_print( GCRYMPI_FMT_PGP, pp[i], &nbytes, pk->pkey[i] );
76         assert( !rc );
77         nn[i] = nbytes;
78         n += nn[i];
79     }
80
81     gcry_md_putc( md, 0x99 );     /* ctb */
82     gcry_md_putc( md, n >> 8 );   /* 2 byte length header */
83     gcry_md_putc( md, n );
84     if( pk->version < 4 )
85         gcry_md_putc( md, 3 );
86     else
87         gcry_md_putc( md, 4 );
88
89     {   u32 a = pk->timestamp;
90         gcry_md_putc( md, a >> 24 );
91         gcry_md_putc( md, a >> 16 );
92         gcry_md_putc( md, a >>  8 );
93         gcry_md_putc( md, a       );
94     }
95     if( pk->version < 4 ) {
96         u16 a;
97
98         if( pk->expiredate )
99             a = (u16)((pk->expiredate - pk->timestamp) / 86400L);
100         else
101             a = 0;
102         gcry_md_putc( md, a >> 8 );
103         gcry_md_putc( md, a      );
104     }
105     gcry_md_putc( md, pk->pubkey_algo );
106     for(i=0; i < npkey; i++ ) {
107         gcry_md_write( md, pp[i], nn[i] );
108         gcry_free(pp[i]);
109     }
110     gcry_md_final( md );
111
112     return md;
113 }
114
115 static GCRY_MD_HD
116 do_fingerprint_md_sk( PKT_secret_key *sk )
117 {
118     PKT_public_key pk;
119     int npkey = pubkey_get_npkey( sk->pubkey_algo ); /* npkey is correct! */
120     int i;
121
122     pk.pubkey_algo = sk->pubkey_algo;
123     pk.version     = sk->version;
124     pk.timestamp = sk->timestamp;
125     pk.expiredate = sk->expiredate;
126     pk.pubkey_algo = sk->pubkey_algo;
127     for( i=0; i < npkey; i++ )
128         pk.pkey[i] = sk->skey[i];
129     return do_fingerprint_md( &pk );
130 }
131
132
133 static void
134 v3_keyid( MPI a, u32 *ki )
135 {
136     int rc;
137     byte *buffer;
138     size_t nbytes;
139
140     rc = gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, a );
141     assert( !rc );
142     /* fixme: allocate it on the stack */
143     buffer = gcry_xmalloc(nbytes);
144     rc = gcry_mpi_print( GCRYMPI_FMT_USG, buffer, &nbytes, a );
145     assert( !rc );
146     if( nbytes < 8 ) { /* oops */
147         ki[0] = ki[1] = 0;
148     }
149     else  {
150         memcpy( ki+0, buffer+nbytes-8, 4);
151         memcpy( ki+1, buffer+nbytes-4, 4);
152     }
153     gcry_free( buffer );
154 }
155
156
157 /****************
158  * Get the keyid from the secret key and put it into keyid
159  * if this is not NULL. Return the 32 low bits of the keyid.
160  */
161 u32
162 keyid_from_sk( PKT_secret_key *sk, u32 *keyid )
163 {
164     u32 dummy_keyid[2];
165
166     if( !keyid )
167         keyid = dummy_keyid;
168
169     if( sk->keyid[0] || sk->keyid[1] ) {
170         keyid[0] = sk->keyid[0];
171         keyid[1] = sk->keyid[1];
172     }
173     else if( sk->version < 4 && is_RSA(sk->pubkey_algo) ) {
174         if( pubkey_get_npkey(sk->pubkey_algo) )
175             v3_keyid( sk->skey[0], keyid ); /* take n */
176         else
177             keyid[0] = keyid[1] = 0;
178         sk->keyid[0] = keyid[0];
179         sk->keyid[1] = keyid[1];
180     }
181     else {
182         const byte *dp;
183         GCRY_MD_HD md;
184         md = do_fingerprint_md_sk(sk);
185         dp = gcry_md_read( md, 0 );
186         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
187         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
188         gcry_md_close(md);
189         sk->keyid[0] = keyid[0];
190         sk->keyid[1] = keyid[1];
191     }
192
193     return keyid[1];
194 }
195
196
197 /****************
198  * Get the keyid from the public key and put it into keyid
199  * if this is not NULL. Return the 32 low bits of the keyid.
200  */
201 u32
202 keyid_from_pk( PKT_public_key *pk, u32 *keyid )
203 {
204     u32 dummy_keyid[2];
205
206     if( !keyid )
207         keyid = dummy_keyid;
208
209     if( pk->keyid[0] || pk->keyid[1] ) {
210         keyid[0] = pk->keyid[0];
211         keyid[1] = pk->keyid[1];
212     }
213     else if( pk->version < 4 && is_RSA(pk->pubkey_algo) ) {
214         if( pubkey_get_npkey(pk->pubkey_algo) )
215             v3_keyid( pk->pkey[0], keyid ); /* from n */
216         else
217             keyid[0] = keyid[1] = 0;
218         pk->keyid[0] = keyid[0];
219         pk->keyid[1] = keyid[1];
220     }
221     else {
222         const byte *dp;
223         GCRY_MD_HD md;
224         md = do_fingerprint_md(pk);
225         dp = gcry_md_read( md, 0 );
226         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
227         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
228         gcry_md_close(md);
229         pk->keyid[0] = keyid[0];
230         pk->keyid[1] = keyid[1];
231     }
232
233     return keyid[1];
234 }
235
236
237 /****************
238  * Get the keyid from the fingerprint.  This function is simple for most
239  * keys, but has to do a keylookup for old stayle keys.
240  */
241 u32
242 keyid_from_fingerprint( const byte *fprint, size_t fprint_len, u32 *keyid )
243 {
244     u32 dummy_keyid[2];
245
246     if( !keyid )
247         keyid = dummy_keyid;
248
249     if( fprint_len != 20 ) {
250         /* This is special as we have to lookup the key first */
251         PKT_public_key pk;
252         int rc;
253
254         memset( &pk, 0, sizeof pk );
255         rc = get_pubkey_byfprint( &pk, fprint, fprint_len );
256         if( rc ) {
257             log_error("Oops: keyid_from_fingerprint: no pubkey\n");
258             keyid[0] = 0;
259             keyid[1] = 0;
260         }
261         else
262             keyid_from_pk( &pk, keyid );
263     }
264     else {
265         const byte *dp = fprint;
266         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
267         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
268     }
269
270     return keyid[1];
271 }
272
273
274 u32
275 keyid_from_sig( PKT_signature *sig, u32 *keyid )
276 {
277     if( keyid ) {
278         keyid[0] = sig->keyid[0];
279         keyid[1] = sig->keyid[1];
280     }
281     return sig->keyid[1];
282 }
283
284 /****************
285  * return the number of bits used in the pk
286  */
287 unsigned
288 nbits_from_pk( PKT_public_key *pk )
289 {
290     return pubkey_nbits( pk->pubkey_algo, pk->pkey );
291 }
292
293 /****************
294  * return the number of bits used in the sk
295  */
296 unsigned
297 nbits_from_sk( PKT_secret_key *sk )
298 {
299     return pubkey_nbits( sk->pubkey_algo, sk->skey );
300 }
301
302 /****************
303  * return a string with the creation date of the pk
304  * Note: this is alloced in a static buffer.
305  *    Format is: yyyy-mm-dd
306  */
307 const char *
308 datestr_from_pk( PKT_public_key *pk )
309 {
310     static char buffer[11+5];
311     struct tm *tp;
312     time_t atime = pk->timestamp;
313
314     tp = gmtime( &atime );
315     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
316     return buffer;
317 }
318
319 const char *
320 datestr_from_sk( PKT_secret_key *sk )
321 {
322     static char buffer[11+5];
323     struct tm *tp;
324     time_t atime = sk->timestamp;
325
326     tp = gmtime( &atime );
327     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
328     return buffer;
329 }
330
331 const char *
332 datestr_from_sig( PKT_signature *sig )
333 {
334     static char buffer[11+5];
335     struct tm *tp;
336     time_t atime = sig->timestamp;
337
338     tp = gmtime( &atime );
339     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
340     return buffer;
341 }
342
343
344 const char *
345 expirestr_from_pk( PKT_public_key *pk )
346 {
347     static char buffer[11+5];
348     struct tm *tp;
349     time_t atime;
350
351     if( !pk->expiredate )
352         return _("never     ");
353     atime = pk->expiredate;
354     tp = gmtime( &atime );
355     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
356     return buffer;
357 }
358
359 const char *
360 expirestr_from_sk( PKT_secret_key *sk )
361 {
362     static char buffer[11+5];
363     struct tm *tp;
364     time_t atime;
365
366     if( !sk->expiredate )
367         return _("never     ");
368     atime = sk->expiredate;
369     tp = gmtime( &atime );
370     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
371     return buffer;
372 }
373
374
375 /**************** .
376  * Return a byte array with the fingerprint for the given PK/SK
377  * The length of the array is returned in ret_len. Caller must free
378  * the array or provide an array of length MAX_FINGERPRINT_LEN.
379  */
380
381 byte *
382 fingerprint_from_pk( PKT_public_key *pk, byte *array, size_t *ret_len )
383 {
384     byte *buf;
385     const char *dp;
386     size_t len;
387
388     if( pk->version < 4 && is_RSA(pk->pubkey_algo) ) {
389         /* RSA in version 3 packets is special */
390         GCRY_MD_HD md;
391
392         md = gcry_md_open( GCRY_MD_MD5, 0);
393         if( !md )
394             BUG();
395         if( pubkey_get_npkey( pk->pubkey_algo ) > 1 ) {
396             int rc;
397             size_t nbytes;
398
399             rc = gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, pk->pkey[0] );
400             assert( !rc );
401             /* fixme: allocate it on the stack */
402             buf = gcry_xmalloc(nbytes);
403             rc = gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, pk->pkey[0] );
404             assert( !rc );
405             gcry_md_write( md, buf, nbytes );
406             gcry_free(buf);
407             rc = gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, pk->pkey[1] );
408             assert( !rc );
409             /* fixme: allocate it on the stack */
410             buf = gcry_xmalloc(nbytes);
411             rc = gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, pk->pkey[1] );
412             assert( !rc );
413             gcry_md_write( md, buf, nbytes );
414             gcry_free(buf);
415         }
416         gcry_md_final(md);
417         if( !array )
418             array = gcry_xmalloc( 16 );
419         len = 16;
420         memcpy(array, gcry_md_read(md, GCRY_MD_MD5), 16 );
421         gcry_md_close(md);
422     }
423     else {
424         GCRY_MD_HD md;
425         md = do_fingerprint_md(pk);
426         dp = gcry_md_read( md, 0 );
427         len = gcry_md_get_algo_dlen( gcry_md_get_algo( md ) );
428         assert( len <= MAX_FINGERPRINT_LEN );
429         if( !array )
430             array = gcry_xmalloc( len );
431         memcpy(array, dp, len );
432         gcry_md_close(md);
433     }
434
435     *ret_len = len;
436     return array;
437 }
438
439
440 /* Create a unified fingerprint, that is a printable fingerprint along
441  * wth some other information suitable to passto get_pubkye_byname.
442  * Pass NULL for buffer to let this function allocate the buffer.
443  * This function will truncate the buffer in a way that a valid C string
444  * is returnd (unless bufsize is 0)
445  * Returns: Supplied buffer or newly allocated buffer
446  */
447 char *
448 unified_fingerprint_from_pk( PKT_public_key *pk,
449                              char *buffer, size_t bufsize )
450 {
451     byte fpr[MAX_FINGERPRINT_LEN];
452     size_t fprlen;
453     int i;
454
455     fingerprint_from_pk( pk, fpr, &fprlen );
456     if ( !buffer ) {
457         bufsize = 1+fprlen*2+1+4+1+1;
458         buffer = gcry_xmalloc( bufsize );
459     }
460     if ( bufsize < 1+fprlen*2+1+4+1+1 ) {
461         /* Hmmm, that should be sufficiend also not very nice */
462         if ( bufsize )
463             *buffer = 0;
464         return buffer;
465     }
466     *buffer = ':';
467     for (i=0; i < fprlen; i++ )
468         sprintf( buffer+1+i*2, "%02X", fpr[i] );
469     sprintf( buffer+1+i*2, ":%d:", (pk->pubkey_algo & 0xff) );
470     return buffer;
471 }
472
473 byte *
474 fingerprint_from_sk( PKT_secret_key *sk, byte *array, size_t *ret_len )
475 {
476     byte *buf;
477     const char *dp;
478     size_t len;
479
480     if( sk->version < 4 && is_RSA(sk->pubkey_algo) ) {
481         /* RSA in version 3 packets is special */
482         GCRY_MD_HD md;
483
484         md = gcry_md_open( GCRY_MD_MD5, 0);
485         if( !md )
486             BUG();
487         if( pubkey_get_npkey( sk->pubkey_algo ) > 1 ) {
488             int rc;
489             size_t nbytes;
490
491             /* FIXME: Why is the hash sequence for secret keys different */
492             rc = gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, sk->skey[1] );
493             assert( !rc );
494             /* fixme: allocate it on the stack */
495             buf = gcry_xmalloc(nbytes);
496             rc = gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, sk->skey[1] );
497             assert( !rc );
498             gcry_md_write( md, buf, nbytes );
499             gcry_free(buf);
500             rc = gcry_mpi_print( GCRYMPI_FMT_USG, NULL, &nbytes, sk->skey[0] );
501             assert( !rc );
502             /* fixme: allocate it on the stack */
503             buf = gcry_xmalloc(nbytes);
504             rc = gcry_mpi_print( GCRYMPI_FMT_USG, buf, &nbytes, sk->skey[0] );
505             assert( !rc );
506             gcry_md_write( md, buf, nbytes );
507             gcry_free(buf);
508         }
509         gcry_md_final(md);
510         if( !array )
511             array = gcry_xmalloc( 16 );
512         len = 16;
513         memcpy(array, gcry_md_read(md, GCRY_MD_MD5), 16 );
514         gcry_md_close(md);
515     }
516     else {
517         GCRY_MD_HD md;
518         md = do_fingerprint_md_sk(sk);
519         dp = gcry_md_read( md, 0 );
520         len = gcry_md_get_algo_dlen( gcry_md_get_algo( md ) );
521         assert( len <= MAX_FINGERPRINT_LEN );
522         if( !array )
523             array = gcry_xmalloc( len );
524         memcpy(array, dp, len );
525         gcry_md_close(md);
526     }
527
528     *ret_len = len;
529     return array;
530 }
531
532 char *
533 unified_fingerprint_from_sk( PKT_secret_key *sk,
534                              char *buffer, size_t bufsize )
535 {
536     byte fpr[MAX_FINGERPRINT_LEN];
537     size_t fprlen;
538     int i;
539
540     fingerprint_from_sk( sk, fpr, &fprlen );
541     if ( !buffer ) {
542         bufsize = 1+fprlen*2+1+4+1+1;
543         buffer = gcry_xmalloc( bufsize );
544     }
545     if ( bufsize < 1+fprlen*2+1+4+1+1 ) {
546         /* Hmmm, that should be sufficiend also not very nice */
547         if ( bufsize )
548             *buffer = 0;
549         return buffer;
550     }
551     *buffer = ':';
552     for (i=0; i < fprlen; i++ )
553         sprintf( buffer+1+i*2, "%02X", fpr[i] );
554     sprintf( buffer+1+i*2, ":%d:", (sk->pubkey_algo & 0xff) );
555     return buffer;
556 }
557
558
559
560
561
562
563
564