added some trust model stuff
[gnupg.git] / g10 / keyid.c
1 /* keyid.c - jeyid and fingerprint handling
2  *      Copyright (c) 1997 by Werner Koch (dd9jn)
3  *
4  * This file is part of G10.
5  *
6  * G10 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  * G10 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 n;
63
64     p1 = buf1 = mpi_get_buffer( pkc->d.elg.p, &n1, NULL );
65     for( ; !*p1 && n1; p1++, n1-- )  /* skip leading null bytes */
66         ;
67     p2 = buf2 = mpi_get_buffer( pkc->d.elg.g, &n2, NULL );
68     for( ; !*p2 && n2; p2++, n2-- )  /* skip leading null bytes */
69         ;
70     p3 = buf3 = mpi_get_buffer( pkc->d.elg.y, &n3, NULL );
71     for( ; !*p3 && n3; p3++, n3-- )  /* skip leading null bytes */
72         ;
73
74     /* calculate length of packet (1+4+2+1+2+n1+2+n2+2+n3) */
75     n = 14 + n1 + n2 + n3;
76     md = md_open( DIGEST_ALGO_RMD160, 0);
77
78     md_putc( md, 0x99 );     /* ctb */
79     md_putc( md, n >> 8 );   /* 2 byte length header */
80     md_putc( md, n );
81     md_putc( md, 3 );        /* version */
82     {   u32 a = pkc->timestamp;
83         md_putc( md, a >> 24 );
84         md_putc( md, a >> 16 );
85         md_putc( md, a >>  8 );
86         md_putc( md, a       );
87     }
88     {   u16 a = pkc->valid_days;
89         md_putc( md, a >> 8 );
90         md_putc( md, a      );
91     }
92     md_putc( md, pkc->pubkey_algo );
93     md_putc( md, n1>>8); md_putc( md, n1 ); md_write( md, p1, n1 );
94     md_putc( md, n2>>8); md_putc( md, n2 ); md_write( md, p2, n2 );
95     md_putc( md, n3>>8); md_putc( md, n3 ); md_write( md, p3, n3 );
96     m_free(buf1);
97     m_free(buf2);
98     m_free(buf3);
99     md_final( md );
100
101     return md;
102 }
103
104
105 static MD_HANDLE
106 v3_elg_fingerprint_md_skc( PKT_secret_cert *skc )
107 {
108     PKT_public_cert pkc;
109
110     pkc.pubkey_algo = skc->pubkey_algo;
111     pkc.timestamp = skc->timestamp;
112     pkc.valid_days = skc->valid_days;
113     pkc.pubkey_algo = skc->pubkey_algo;
114     pkc.d.elg.p = skc->d.elg.p;
115     pkc.d.elg.g = skc->d.elg.g;
116     pkc.d.elg.y = skc->d.elg.y;
117     return v3_elg_fingerprint_md( &pkc );
118 }
119
120
121 /****************
122  * Get the keyid from the secret key certificate and put it into keyid
123  * if this is not NULL. Return the 32 low bits of the keyid.
124  */
125 u32
126 keyid_from_skc( PKT_secret_cert *skc, u32 *keyid )
127 {
128     u32 lowbits;
129     u32 dummy_keyid[2];
130
131     if( !keyid )
132         keyid = dummy_keyid;
133
134     if( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
135         const byte *dp;
136         MD_HANDLE md;
137         md = v3_elg_fingerprint_md_skc(skc);
138         dp = md_read( md, DIGEST_ALGO_RMD160 );
139         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
140         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
141         lowbits = keyid[1];
142         md_close(md);
143     }
144     else if( skc->pubkey_algo == PUBKEY_ALGO_RSA ) {
145         lowbits = mpi_get_keyid( skc->d.rsa.rsa_n, keyid );
146     }
147     else {
148         keyid[0] = keyid[1] = lowbits = 0;
149     }
150     return lowbits;
151 }
152
153
154 /****************
155  * Get the keyid from the public key certificate and put it into keyid
156  * if this is not NULL. Return the 32 low bits of the keyid.
157  */
158 u32
159 keyid_from_pkc( PKT_public_cert *pkc, u32 *keyid )
160 {
161     u32 lowbits;
162     u32 dummy_keyid[2];
163
164     if( !keyid )
165         keyid = dummy_keyid;
166
167     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
168         const byte *dp;
169         MD_HANDLE md;
170         md = v3_elg_fingerprint_md(pkc);
171         dp = md_read( md, DIGEST_ALGO_RMD160 );
172         keyid[0] = dp[12] << 24 | dp[13] << 16 | dp[14] << 8 | dp[15] ;
173         keyid[1] = dp[16] << 24 | dp[17] << 16 | dp[18] << 8 | dp[19] ;
174         lowbits = keyid[1];
175         md_close(md);
176     }
177     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
178         lowbits = mpi_get_keyid( pkc->d.rsa.rsa_n, keyid );
179     }
180     else {
181         keyid[0] = keyid[1] = lowbits = 0;
182     }
183
184     return lowbits;
185 }
186
187
188 u32
189 keyid_from_sig( PKT_signature *sig, u32 *keyid )
190 {
191     if( keyid ) {
192         keyid[0] = sig->keyid[0];
193         keyid[1] = sig->keyid[1];
194     }
195     return sig->keyid[1];
196 }
197
198 /****************
199  * return the number of bits used in the pkc
200  */
201 unsigned
202 nbits_from_pkc( PKT_public_cert *pkc )
203 {
204     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
205         return mpi_get_nbits( pkc->d.elg.p );
206     }
207     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
208         return mpi_get_nbits( pkc->d.rsa.rsa_n );
209     }
210     else
211         return 0;
212 }
213
214 /****************
215  * return the number of bits used in the skc
216  */
217 unsigned
218 nbits_from_skc( PKT_secret_cert *skc )
219 {
220     if( skc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
221         return mpi_get_nbits( skc->d.elg.p );
222     }
223     else if( skc->pubkey_algo == PUBKEY_ALGO_RSA ) {
224         return mpi_get_nbits( skc->d.rsa.rsa_n );
225     }
226     else
227         return 0;
228 }
229
230 /****************
231  * return a string with the creation date of the pkc
232  * Note: this is alloced in a static buffer.
233  *    Format is: yyyy-mm-dd
234  */
235 const char *
236 datestr_from_pkc( PKT_public_cert *pkc )
237 {
238     static char buffer[11+5];
239     struct tm *tp;
240     time_t atime = pkc->timestamp;
241
242     tp = gmtime( &atime );
243     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
244     return buffer;
245 }
246
247 const char *
248 datestr_from_skc( PKT_secret_cert *skc )
249 {
250     static char buffer[11+5];
251     struct tm *tp;
252     time_t atime = skc->timestamp;
253
254     tp = gmtime( &atime );
255     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
256     return buffer;
257 }
258
259 const char *
260 datestr_from_sig( PKT_signature *sig )
261 {
262     static char buffer[11+5];
263     struct tm *tp;
264     time_t atime = sig->timestamp;
265
266     tp = gmtime( &atime );
267     sprintf(buffer,"%04d-%02d-%02d", 1900+tp->tm_year, tp->tm_mon+1, tp->tm_mday );
268     return buffer;
269 }
270
271
272 /**************** .
273  * Return a byte array with the fingerprint for the given PKC/SKC
274  * The length of the array is returned in ret_len. Caller must free
275  * the array.
276  */
277 byte *
278 fingerprint_from_skc( PKT_secret_cert *skc, size_t *ret_len )
279 {
280     PKT_public_cert pkc;
281     byte *p;
282
283     pkc.pubkey_algo = skc->pubkey_algo;
284     if( pkc.pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
285         pkc.timestamp = skc->timestamp;
286         pkc.valid_days = skc->valid_days;
287         pkc.pubkey_algo = skc->pubkey_algo;
288         pkc.d.elg.p = skc->d.elg.p;
289         pkc.d.elg.g = skc->d.elg.g;
290         pkc.d.elg.y = skc->d.elg.y;
291     }
292     else if( pkc.pubkey_algo == PUBKEY_ALGO_RSA ) {
293         pkc.d.rsa.rsa_n = skc->d.rsa.rsa_n;
294         pkc.d.rsa.rsa_e = skc->d.rsa.rsa_e;
295     }
296     p = fingerprint_from_pkc( &pkc, ret_len );
297     memset(&pkc, 0, sizeof pkc); /* not really needed */
298     return p;
299 }
300
301
302
303
304 byte *
305 fingerprint_from_pkc( PKT_public_cert *pkc, size_t *ret_len )
306 {
307     byte *p, *buf, *array;
308     const char *dp;
309     size_t len;
310     unsigned n;
311
312     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL ) {
313         MD_HANDLE md;
314         md = v3_elg_fingerprint_md(pkc);
315         dp = md_read( md, DIGEST_ALGO_RMD160 );
316         array = m_alloc( 20 );
317         len = 20;
318         memcpy(array, dp, 20 );
319         md_close(md);
320     }
321     else if( pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
322         MD_HANDLE md;
323
324         md = md_open( DIGEST_ALGO_MD5, 0);
325         p = buf = mpi_get_buffer( pkc->d.rsa.rsa_n, &n, NULL );
326         for( ; !*p && n; p++, n-- )
327             ;
328         md_write( md, p, n );
329         m_free(buf);
330         p = buf = mpi_get_buffer( pkc->d.rsa.rsa_e, &n, NULL );
331         for( ; !*p && n; p++, n-- )
332             ;
333         md_write( md, p, n );
334         m_free(buf);
335         md_final(md);
336         array = m_alloc( 16 );
337         len = 16;
338         memcpy(array, md_read(md, DIGEST_ALGO_MD5), 16 );
339         md_close(md);
340     }
341     else {
342         array = m_alloc(1);
343         len = 0; /* ooops */
344     }
345
346     *ret_len = len;
347     return array;
348 }
349
350
351