some cleanups
[gnupg.git] / g10 / keyid.c
1 /* keyid.c - jeyid and fingerprint handling
2  *      Copyright (C) 1998 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 #include "util.h"
29 #include "main.h"
30 #include "packet.h"
31 #include "options.h"
32 #include "mpi.h"
33 #include "keydb.h"
34
35
36 int
37 pubkey_letter( int algo )
38 {
39     switch( algo ) {
40       case PUBKEY_ALGO_RSA:     return 'R' ;
41       case PUBKEY_ALGO_RSA_E:   return 'r' ;
42       case PUBKEY_ALGO_RSA_S:   return 's' ;
43       case PUBKEY_ALGO_ELGAMAL: return 'G' ;
44       case PUBKEY_ALGO_DSA:     return 'D' ;
45       default: return '?';
46     }
47 }
48
49 /* this is special code for V3 which uses ElGamal and
50  * calculates a fingerprint like V4, but with rmd160
51  * and a version byte of 3. Returns an md handle, caller must
52  * do md_close()
53  */
54
55 static MD_HANDLE
56 v3_elg_fingerprint_md( PKT_public_cert *pkc )
57 {
58     MD_HANDLE md;
59     byte *buf1, *buf2, *buf3;
60     byte *p1, *p2, *p3;
61     unsigned n1, n2, n3;
62     unsigned nb1, nb2, nb3;
63     unsigned n;
64
65     nb1 = mpi_get_nbits(pkc->d.elg.p);
66     p1 = buf1 = mpi_get_buffer( pkc->d.elg.p, &n1, NULL );
67     for( ; !*p1 && n1; p1++, n1-- )  /* skip leading null bytes */
68         ;
69     nb2 = mpi_get_nbits(pkc->d.elg.g);
70     p2 = buf2 = mpi_get_buffer( pkc->d.elg.g, &n2, NULL );
71     for( ; !*p2 && n2; p2++, n2-- )  /* skip leading null bytes */
72         ;
73     nb3 = mpi_get_nbits(pkc->d.elg.y);
74     p3 = buf3 = mpi_get_buffer( pkc->d.elg.y, &n3, NULL );
75     for( ; !*p3 && n3; p3++, n3-- )  /* skip leading null bytes */
76         ;
77
78     /* calculate length of packet (1+4+2+1+2+n1+2+n2+2+n3) */
79     n = 14 + n1 + n2 + n3;
80     md = md_open( DIGEST_ALGO_RMD160, 0);
81
82     md_putc( md, 0x99 );     /* ctb */
83     md_putc( md, n >> 8 );   /* 2 byte length header */
84     md_putc( md, n );
85     md_putc( md, 3 );        /* version */
86     {   u32 a = pkc->timestamp;
87         md_putc( md, a >> 24 );
88         md_putc( md, a >> 16 );
89         md_putc( md, a >>  8 );
90         md_putc( md, a       );
91     }
92     {   u16 a = pkc->valid_days;
93         md_putc( md, a >> 8 );
94         md_putc( md, a      );
95     }
96     md_putc( md, pkc->pubkey_algo );
97     md_putc( md, nb1>>8); md_putc( md, nb1 ); md_write( md, p1, n1 );
98     md_putc( md, nb2>>8); md_putc( md, nb2 ); md_write( md, p2, n2 );
99     md_putc( md, nb3>>8); md_putc( md, nb3 ); md_write( md, p3, n3 );
100     m_free(buf1);
101     m_free(buf2);
102     m_free(buf3);
103     md_final( md );
104
105     return md;
106 }
107
108 static MD_HANDLE
109 elg_fingerprint_md( PKT_public_cert *pkc )
110 {
111     MD_HANDLE md;
112     byte *buf1, *buf3, *buf4 ;
113     byte *p1, *p3, *p4;
114     unsigned n1, n3, n4;
115     unsigned nb1, nb3, nb4;
116     unsigned n;
117
118     nb1 = mpi_get_nbits(pkc->d.dsa.p);
119     p1 = buf1 = mpi_get_buffer( pkc->d.dsa.p, &n1, NULL );
120     for( ; !*p1 && n1; p1++, n1-- )  /* skip leading null bytes */
121         ;
122     nb3 = mpi_get_nbits(pkc->d.dsa.g);
123     p3 = buf3 = mpi_get_buffer( pkc->d.dsa.g, &n3, NULL );
124     for( ; !*p3 && n3; p3++, n3-- )
125         ;
126     nb4 = mpi_get_nbits(pkc->d.dsa.y);
127     p4 = buf4 = mpi_get_buffer( pkc->d.dsa.y, &n4, NULL );
128     for( ; !*p4 && n4; p4++, n4-- )
129         ;
130
131     /* calculate length of packet */
132     n = 12 + n1 + n3 +n4 ;
133     md = md_open( DIGEST_ALGO_SHA1, 0);
134
135     md_putc( md, 0x99 );     /* ctb */
136     md_putc( md, n >> 8 );   /* 2 byte length header */
137     md_putc( md, n );
138     md_putc( md, 4 );        /* version */
139     {   u32 a = pkc->timestamp;
140         md_putc( md, a >> 24 );
141         md_putc( md, a >> 16 );
142         md_putc( md, a >>  8 );
143         md_putc( md, a       );
144     }
145     md_putc( md, pkc->pubkey_algo );
146     md_putc( md, nb1>>8); md_putc( md, nb1 ); md_write( md, p1, n1 );
147     md_putc( md, nb3>>8); md_putc( md, nb3 ); md_write( md, p3, n3 );
148     md_putc( md, nb4>>8); md_putc( md, nb4 ); md_write( md, p4, n4 );
149     m_free(buf1);
150     m_free(buf3);
151     m_free(buf4);
152     md_final( md );
153
154     return md;
155 }
156
157
158 static MD_HANDLE
159 dsa_fingerprint_md( PKT_public_cert *pkc )
160 {
161     MD_HANDLE md;
162     byte *buf1, *buf2, *buf3, *buf4 ;
163     byte *p1, *p2, *p3, *p4;
164     unsigned n1, n2, n3, n4;
165     unsigned nb1, nb2, nb3, nb4;
166     unsigned n;
167
168     nb1 = mpi_get_nbits(pkc->d.dsa.p);
169     p1 = buf1 = mpi_get_buffer( pkc->d.dsa.p, &n1, NULL );
170     for( ; !*p1 && n1; p1++, n1-- )  /* skip leading null bytes */
171         ;
172     nb2 = mpi_get_nbits(pkc->d.dsa.q);
173     p2 = buf2 = mpi_get_buffer( pkc->d.dsa.q, &n2, NULL );
174     for( ; !*p2 && n2; p2++, n2-- )
175         ;
176     nb3 = mpi_get_nbits(pkc->d.dsa.g);
177     p3 = buf3 = mpi_get_buffer( pkc->d.dsa.g, &n3, NULL );
178     for( ; !*p3 && n3; p3++, n3-- )
179         ;
180     nb4 = mpi_get_nbits(pkc->d.dsa.y);
181     p4 = buf4 = mpi_get_buffer( pkc->d.dsa.y, &n4, NULL );
182     for( ; !*p4 && n4; p4++, n4-- )
183         ;
184
185     /* calculate length of packet */
186     n = 14 + n1 + n2 + n3 +n4 ;
187     md = md_open( DIGEST_ALGO_SHA1, 0);
188
189     md_putc( md, 0x99 );     /* ctb */
190     md_putc( md, n >> 8 );   /* 2 byte length header */
191     md_putc( md, n );
192     md_putc( md, 4 );        /* version */
193     {   u32 a = pkc->timestamp;
194         md_putc( md, a >> 24 );
195         md_putc( md, a >> 16 );
196         md_putc( md, a >>  8 );
197         md_putc( md, a       );
198     }
199     md_putc( md, pkc->pubkey_algo );
200     md_putc( md, nb1>>8); md_putc( md, nb1 ); md_write( md, p1, n1 );
201     md_putc( md, nb2>>8); md_putc( md, nb2 ); md_write( md, p2, n2 );
202     md_putc( md, nb3>>8); md_putc( md, nb3 ); md_write( md, p3, n3 );
203     md_putc( md, nb4>>8); md_putc( md, nb4 ); md_write( md, p4, n4 );
204     m_free(buf1);
205     m_free(buf2);
206     m_free(buf3);
207     m_free(buf4);
208     md_final( md );
209
210     return md;
211 }
212
213 static MD_HANDLE
214 elg_fingerprint_md_skc( PKT_secret_cert *skc )
215 {
216     PKT_public_cert pkc;
217
218     pkc.pubkey_algo = skc->pubkey_algo;
219     pkc.version     = skc->version;
220     pkc.timestamp = skc->timestamp;
221     pkc.valid_days = skc->valid_days;
222     pkc.pubkey_algo = skc->pubkey_algo;
223     pkc.d.elg.p = skc->d.elg.p;
224     pkc.d.elg.g = skc->d.elg.g;
225     pkc.d.elg.y = skc->d.elg.y;
226     if( pkc.version < 4 )
227         return v3_elg_fingerprint_md( &pkc );
228     else
229         return elg_fingerprint_md( &pkc );
230 }
231
232 static MD_HANDLE
233 dsa_fingerprint_md_skc( PKT_secret_cert *skc )
234 {
235     PKT_public_cert pkc;
236
237     pkc.pubkey_algo = skc->pubkey_algo;
238     pkc.timestamp = skc->timestamp;
239     pkc.pubkey_algo = skc->pubkey_algo;
240     pkc.d.dsa.p = skc->d.dsa.p;
241     pkc.d.dsa.q = skc->d.dsa.q;
242     pkc.d.dsa.g = skc->d.dsa.g;
243     pkc.d.dsa.y = skc->d.dsa.y;
244     return dsa_fingerprint_md( &pkc );
245 }
246
247
248 /****************
249  * Get the keyid from the secret key certificate and put it into keyid
250  * if this is not NULL. Return the 32 low bits of the keyid.
251  */
252 u32
253 keyid_from_skc( PKT_secret_cert *skc, u32 *keyid )
254 {
255     u32 lowbits;
256     u32 dummy_keyid[2];
257
258     if( !keyid )
259         keyid = dummy_keyid;
260
261     if( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
262         const byte *dp;
263         MD_HANDLE md;
264         md = elg_fingerprint_md_skc(skc);
265         if( skc->version < 4 )
266             dp = md_read( md, DIGEST_ALGO_RMD160 );
267         else
268             dp = md_read( md, DIGEST_ALGO_SHA1 );
269         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
270         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
271         lowbits = keyid[1];
272         md_close(md);
273     }
274     else if( skc->pubkey_algo == PUBKEY_ALGO_DSA ) {
275         const byte *dp;
276         MD_HANDLE md;
277         md = dsa_fingerprint_md_skc(skc);
278         dp = md_read( md, DIGEST_ALGO_SHA1 );
279         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
280         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
281         lowbits = keyid[1];
282         md_close(md);
283     }
284     else if( skc->pubkey_algo == PUBKEY_ALGO_RSA ) {
285         lowbits = mpi_get_keyid( skc->d.rsa.rsa_n, keyid );
286     }
287     else {
288         keyid[0] = keyid[1] = lowbits = 0;
289     }
290     return lowbits;
291 }
292
293
294 /****************
295  * Get the keyid from the public key certificate and put it into keyid
296  * if this is not NULL. Return the 32 low bits of the keyid.
297  */
298 u32
299 keyid_from_pkc( PKT_public_cert *pkc, u32 *keyid )
300 {
301     u32 lowbits;
302     u32 dummy_keyid[2];
303
304     if( !keyid )
305         keyid = dummy_keyid;
306
307     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
308         const byte *dp;
309         MD_HANDLE md;
310         if( pkc->version < 4 ) {
311             md = v3_elg_fingerprint_md(pkc);
312             dp = md_read( md, DIGEST_ALGO_RMD160 );
313         }
314         else {
315             md = elg_fingerprint_md(pkc);
316             dp = md_read( md, DIGEST_ALGO_SHA1 );
317         }
318         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
319         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
320         lowbits = keyid[1];
321         md_close(md);
322     }
323     else if( pkc->pubkey_algo == PUBKEY_ALGO_DSA  ) {
324         const byte *dp;
325         MD_HANDLE md;
326         md = dsa_fingerprint_md(pkc);
327         dp = md_read( md, DIGEST_ALGO_SHA1 );
328         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
329         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
330         lowbits = keyid[1];
331         md_close(md);
332     }
333     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
334         lowbits = mpi_get_keyid( pkc->d.rsa.rsa_n, keyid );
335     }
336     else {
337         keyid[0] = keyid[1] = lowbits = 0;
338     }
339
340     return lowbits;
341 }
342
343
344 u32
345 keyid_from_sig( PKT_signature *sig, u32 *keyid )
346 {
347     if( keyid ) {
348         keyid[0] = sig->keyid[0];
349         keyid[1] = sig->keyid[1];
350     }
351     return sig->keyid[1];
352 }
353
354 /****************
355  * return the number of bits used in the pkc
356  */
357 unsigned
358 nbits_from_pkc( PKT_public_cert *pkc )
359 {
360     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
361         return mpi_get_nbits( pkc->d.elg.p );
362     }
363     else if( pkc->pubkey_algo == PUBKEY_ALGO_DSA ) {
364         return mpi_get_nbits( pkc->d.dsa.p );
365     }
366     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
367         return mpi_get_nbits( pkc->d.rsa.rsa_n );
368     }
369     else
370         return 0;
371 }
372
373 /****************
374  * return the number of bits used in the skc
375  */
376 unsigned
377 nbits_from_skc( PKT_secret_cert *skc )
378 {
379     if( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
380         return mpi_get_nbits( skc->d.elg.p );
381     }
382     else if( skc->pubkey_algo == PUBKEY_ALGO_DSA ) {
383         return mpi_get_nbits( skc->d.dsa.p );
384     }
385     else if( skc->pubkey_algo == PUBKEY_ALGO_RSA ) {
386         return mpi_get_nbits( skc->d.rsa.rsa_n );
387     }
388     else
389         return 0;
390 }
391
392 /****************
393  * return a string with the creation date of the pkc
394  * Note: this is alloced in a static buffer.
395  *    Format is: yyyy-mm-dd
396  */
397 const char *
398 datestr_from_pkc( PKT_public_cert *pkc )
399 {
400     static char buffer[11+5];
401     struct tm *tp;
402     time_t atime = pkc->timestamp;
403
404     tp = gmtime( &atime );
405     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
406     return buffer;
407 }
408
409 const char *
410 datestr_from_skc( PKT_secret_cert *skc )
411 {
412     static char buffer[11+5];
413     struct tm *tp;
414     time_t atime = skc->timestamp;
415
416     tp = gmtime( &atime );
417     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
418     return buffer;
419 }
420
421 const char *
422 datestr_from_sig( PKT_signature *sig )
423 {
424     static char buffer[11+5];
425     struct tm *tp;
426     time_t atime = sig->timestamp;
427
428     tp = gmtime( &atime );
429     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
430     return buffer;
431 }
432
433
434 /**************** .
435  * Return a byte array with the fingerprint for the given PKC/SKC
436  * The length of the array is returned in ret_len. Caller must free
437  * the array.
438  */
439 byte *
440 fingerprint_from_skc( PKT_secret_cert *skc, size_t *ret_len )
441 {
442     PKT_public_cert pkc;
443     byte *p;
444
445     pkc.pubkey_algo = skc->pubkey_algo;
446     pkc.version     = skc->version;
447     if( pkc.pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
448         pkc.timestamp = skc->timestamp;
449         pkc.valid_days = skc->valid_days;
450         pkc.pubkey_algo = skc->pubkey_algo;
451         pkc.d.elg.p = skc->d.elg.p;
452         pkc.d.elg.g = skc->d.elg.g;
453         pkc.d.elg.y = skc->d.elg.y;
454     }
455     else if( pkc.pubkey_algo == PUBKEY_ALGO_DSA ) {
456         pkc.timestamp = skc->timestamp;
457         pkc.valid_days = skc->valid_days;
458         pkc.pubkey_algo = skc->pubkey_algo;
459         pkc.d.dsa.p = skc->d.dsa.p;
460         pkc.d.dsa.q = skc->d.dsa.q;
461         pkc.d.dsa.g = skc->d.dsa.g;
462         pkc.d.dsa.y = skc->d.dsa.y;
463     }
464     else if( pkc.pubkey_algo == PUBKEY_ALGO_RSA ) {
465         pkc.d.rsa.rsa_n = skc->d.rsa.rsa_n;
466         pkc.d.rsa.rsa_e = skc->d.rsa.rsa_e;
467     }
468     p = fingerprint_from_pkc( &pkc, ret_len );
469     memset(&pkc, 0, sizeof pkc); /* not really needed */
470     return p;
471 }
472
473
474
475
476 byte *
477 fingerprint_from_pkc( PKT_public_cert *pkc, size_t *ret_len )
478 {
479     byte *p, *buf, *array;
480     const char *dp;
481     size_t len;
482     unsigned n;
483
484     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
485         MD_HANDLE md;
486         if( pkc->version < 4 ) {
487             md = v3_elg_fingerprint_md(pkc);
488             dp = md_read( md, DIGEST_ALGO_RMD160 );
489         }
490         else {
491             md = elg_fingerprint_md(pkc);
492             dp = md_read( md, DIGEST_ALGO_SHA1 );
493         }
494         array = m_alloc( 20 );
495         len = 20;
496         memcpy(array, dp, 20 );
497         md_close(md);
498     }
499     else if( pkc->pubkey_algo == PUBKEY_ALGO_DSA ) {
500         MD_HANDLE md;
501         md = dsa_fingerprint_md(pkc);
502         dp = md_read( md, DIGEST_ALGO_SHA1 );
503         array = m_alloc( 20 );
504         len = 20;
505         memcpy(array, dp, 20 );
506         md_close(md);
507     }
508     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
509         MD_HANDLE md;
510
511         md = md_open( DIGEST_ALGO_MD5, 0);
512         p = buf = mpi_get_buffer( pkc->d.rsa.rsa_n, &n, NULL );
513         for( ; !*p && n; p++, n-- )
514             ;
515         md_write( md, p, n );
516         m_free(buf);
517         p = buf = mpi_get_buffer( pkc->d.rsa.rsa_e, &n, NULL );
518         for( ; !*p && n; p++, n-- )
519             ;
520         md_write( md, p, n );
521         m_free(buf);
522         md_final(md);
523         array = m_alloc( 16 );
524         len = 16;
525         memcpy(array, md_read(md, DIGEST_ALGO_MD5), 16 );
526         md_close(md);
527     }
528     else {
529         array = m_alloc(1);
530         len = 0; /* ooops */
531     }
532
533     *ret_len = len;
534     return array;
535 }
536
537
538