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