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