fingerprints and self signatures added
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
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 <assert.h>
26 #include "util.h"
27 #include "packet.h"
28 #include "memory.h"
29 #include "iobuf.h"
30 #include "keydb.h"
31 #include "options.h"
32
33 #define MAX_PKC_CACHE_ENTRIES 500
34
35
36 typedef struct keyid_list {
37     struct keyid_list *next;
38     u32 keyid[2];
39 } *keyid_list_t;
40
41 typedef struct user_id_db {
42     struct user_id_db *next;
43     u32 keyid[2];
44     int len;
45     char name[1];
46 } *user_id_db_t;
47
48 typedef struct pkc_cache_entry {
49     struct pkc_cache_entry *next;
50     u32 keyid[2];
51     PKT_public_cert *pkc;
52 } *pkc_cache_entry_t;
53
54 static STRLIST keyrings;
55
56 static keyid_list_t unknown_keyids;
57 static user_id_db_t user_id_db;
58 static pkc_cache_entry_t pkc_cache;
59 static int pkc_cache_entries;   /* number of entries in pkc cache */
60
61
62 static int scan_keyring( PKT_public_cert *pkc, u32 *keyid,
63                          const char *name, const char *filename );
64 static int scan_secret_keyring( PKT_secret_cert *skc, u32 *keyid,
65                                 const char *name, const char *filename);
66
67
68 void
69 add_keyring( const char *name )
70 {
71     STRLIST sl;
72
73     /* FIXME: check wether this one is available etc */
74     /* my be we should do this later */
75     sl = m_alloc( sizeof *sl + strlen(name) );
76     strcpy(sl->d, name );
77     sl->next = keyrings;
78     keyrings = sl;
79 }
80
81
82 void
83 cache_public_cert( PKT_public_cert *pkc )
84 {
85     pkc_cache_entry_t ce;
86     u32 keyid[2];
87
88     if( pkc->pubkey_algo == PUBKEY_ALGO_ELGAMAL
89         || pkc->pubkey_algo == PUBKEY_ALGO_RSA ) {
90         keyid_from_pkc( pkc, keyid );
91     }
92     else
93         return; /* don't know how to get the keyid */
94
95     for( ce = pkc_cache; ce; ce = ce->next )
96         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
97             if( DBG_CACHE )
98                 log_debug("cache_public_cert: already in cache\n");
99             return;
100         }
101
102     if( pkc_cache_entries > MAX_PKC_CACHE_ENTRIES ) {
103         /* FIMXE: use another algorithm to free some cache slots */
104         if( pkc_cache_entries == MAX_PKC_CACHE_ENTRIES )  {
105             pkc_cache_entries++;
106             log_info("too many entries in pkc cache - disabled\n");
107         }
108         ce = pkc_cache;
109         free_public_cert( ce->pkc );
110     }
111     else {
112         pkc_cache_entries++;
113         ce = m_alloc( sizeof *ce );
114         ce->next = pkc_cache;
115         pkc_cache = ce;
116     }
117     ce->pkc = copy_public_cert( NULL, pkc );
118     ce->keyid[0] = keyid[0];
119     ce->keyid[1] = keyid[1];
120 }
121
122
123 /****************
124  * Store the association of keyid and userid
125  */
126 void
127 cache_user_id( PKT_user_id *uid, u32 *keyid )
128 {
129     user_id_db_t r;
130
131     for(r=user_id_db; r; r = r->next )
132         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
133             if( DBG_CACHE )
134                 log_debug("cache_user_id: already in cache\n");
135             return;
136         }
137
138     r = m_alloc( sizeof *r + uid->len-1 );
139     r->keyid[0] = keyid[0];
140     r->keyid[1] = keyid[1];
141     r->len = uid->len;
142     memcpy(r->name, uid->name, r->len);
143     r->next = user_id_db;
144     user_id_db = r;
145 }
146
147
148
149 /****************
150  * Get a public key and store it into the allocated pkc
151  * can be called with PKC set to NULL to just read it into some
152  * internal structures.
153  */
154 int
155 get_pubkey( PKT_public_cert *pkc, u32 *keyid )
156 {
157     keyid_list_t kl;
158     int internal = 0;
159     int rc = 0;
160     pkc_cache_entry_t ce;
161     STRLIST sl;
162
163
164     if( opt.cache_all && !pkc_cache ) {
165         log_info("reading all entries ...\n");
166         for(sl = keyrings; sl; sl = sl->next )
167             if( !scan_keyring( NULL, NULL, NULL, sl->d ) )
168                 goto leave;
169         log_info("cached %d entries\n", pkc_cache_entries);
170     }
171
172
173     /* lets see wether we checked the keyid already */
174     for( kl = unknown_keyids; kl; kl = kl->next )
175         if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
176             return G10ERR_NO_PUBKEY; /* already checked and not found */
177
178     /* 1. Try to get it from our cache */
179     for( ce = pkc_cache; ce; ce = ce->next )
180         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
181             if( pkc )
182                 copy_public_cert( pkc, ce->pkc );
183             return 0;
184         }
185
186     /* more init stuff */
187     if( !pkc ) {
188         pkc = m_alloc_clear( sizeof *pkc );
189         internal++;
190     }
191
192
193     /* 2. Try to get it from the keyrings */
194     for(sl = keyrings; sl; sl = sl->next )
195         if( !scan_keyring( pkc, keyid, NULL, sl->d ) )
196             goto leave;
197
198     /* 3. Try to get it from a key server */
199
200     /* 4. not found: store it for future reference */
201     kl = m_alloc( sizeof *kl );
202     kl->keyid[0] = keyid[0];
203     kl->keyid[1] = keyid[1];
204     kl->next = unknown_keyids;
205     unknown_keyids = kl;
206     rc = G10ERR_NO_PUBKEY;
207
208   leave:
209     if( !rc )
210         cache_public_cert( pkc );
211     if( internal )
212         m_free(pkc);
213     return rc;
214 }
215
216
217 /****************
218  * Try to get the pubkey by the userid. This functions looks for the
219  * first pubkey certificate which has the given name in a user_id.
220  * if pkc has the pubkey algo set, the function will only return
221  * a pubkey with that algo.
222  */
223 int
224 get_pubkey_by_name( PKT_public_cert *pkc, const char *name )
225 {
226     int internal = 0;
227     int rc = 0;
228     STRLIST sl;
229
230     if( !pkc ) {
231         pkc = m_alloc_clear( sizeof *pkc );
232         internal++;
233     }
234
235     /* 2. Try to get it from the keyrings */
236     for(sl = keyrings; sl; sl = sl->next )
237         if( !scan_keyring( pkc, NULL, name, sl->d ) )
238             goto leave;
239
240     /* 3. Try to get it from a key server */
241
242     /* 4. not found: store it for future reference */
243     rc = G10ERR_NO_PUBKEY;
244
245   leave:
246     if( internal )
247         m_free(pkc);
248     return rc;
249 }
250
251
252 /****************
253  * Get a secret key and store it into skey
254  */
255 int
256 get_seckey( PKT_secret_cert *skc, u32 *keyid )
257 {
258     int rc=0;
259
260     if( !(rc=scan_secret_keyring( skc, keyid, NULL, "../keys/secring.g10" ) ) )
261         goto found;
262     /* fixme: look at other places */
263     goto leave;
264
265   found:
266     /* get the secret key (this may prompt for a passprase to
267      * unlock the secret key
268      */
269     if( (rc = check_secret_key( skc )) )
270         goto leave;
271
272   leave:
273     return rc;
274 }
275
276 /****************
277  * Get a secret key by name and store it into skc
278  * If NAME is NULL use the default certificate
279  */
280 int
281 get_seckey_by_name( PKT_secret_cert *skc, const char *name )
282 {
283     int rc=0;
284
285     if( !(rc=scan_secret_keyring( skc, NULL, name, "../keys/secring.g10" ) ) )
286         goto found;
287     /* fixme: look at other places */
288     goto leave;
289
290   found:
291     /* get the secret key (this may prompt for a passprase to
292      * unlock the secret key
293      */
294     if( (rc = check_secret_key( skc )) )
295         goto leave;
296
297   leave:
298     return rc;
299 }
300
301
302 /****************
303  * scan the keyring and look for either the keyid or the name.
304  */
305 static int
306 scan_keyring( PKT_public_cert *pkc, u32 *keyid,
307               const char *name, const char *filename )
308 {
309     int rc=0;
310     int found = 0;
311     IOBUF a;
312     PACKET pkt;
313     int save_mode;
314     u32 akeyid[2];
315     PKT_public_cert *last_pk = NULL;
316
317     assert( !keyid || !name );
318
319     if( opt.cache_all && (name || keyid) )
320         return G10ERR_NO_PUBKEY;
321
322     if( !(a = iobuf_open( filename ) ) ) {
323         log_debug("scan_keyring: can't open '%s'\n", filename );
324         return G10ERR_KEYRING_OPEN;
325     }
326
327     if( !DBG_CACHE )
328         ;
329     else if( name )
330         log_debug("scan_keyring %s for '%s'\n",  filename, name );
331     else if( keyid )
332         log_debug("scan_keyring %s for %08lx %08lx\n",  filename,
333                                                 keyid[0], keyid[1] );
334     else
335         log_debug("scan_keyring %s (all)\n",  filename );
336
337     save_mode = set_packet_list_mode(0);
338     init_packet(&pkt);
339     while( (rc=parse_packet(a, &pkt)) != -1 ) {
340         if( rc )
341             ; /* e.g. unknown packet */
342         else if( keyid && found && pkt.pkttype == PKT_PUBLIC_CERT ) {
343             log_error("Hmmm, pubkey without an user id in '%s'\n", filename);
344             goto leave;
345         }
346         else if( keyid && pkt.pkttype == PKT_PUBLIC_CERT ) {
347             switch( pkt.pkt.public_cert->pubkey_algo ) {
348               case PUBKEY_ALGO_ELGAMAL:
349               case PUBKEY_ALGO_RSA:
350                 keyid_from_pkc( pkt.pkt.public_cert, akeyid );
351                 if( akeyid[0] == keyid[0] && akeyid[1] == keyid[1] ) {
352                     copy_public_cert( pkc, pkt.pkt.public_cert );
353                     found++;
354                 }
355                 break;
356               default:
357                 log_error("cannot handle pubkey algo %d\n",
358                                      pkt.pkt.public_cert->pubkey_algo);
359             }
360         }
361         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
362             cache_user_id( pkt.pkt.user_id, keyid );
363             goto leave;
364         }
365         else if( name && pkt.pkttype == PKT_PUBLIC_CERT ) {
366             if( last_pk )
367                 free_public_cert(last_pk);
368             last_pk = pkt.pkt.public_cert;
369             pkt.pkt.public_cert = NULL;
370         }
371         else if( name && pkt.pkttype == PKT_USER_ID ) {
372             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
373                 if( !last_pk )
374                     log_error("Ooops: no pubkey for userid '%.*s'\n",
375                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
376                 else if( pkc->pubkey_algo &&
377                          pkc->pubkey_algo != last_pk->pubkey_algo )
378                     log_info("skipping id '%.*s': want algo %d, found %d\n",
379                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
380                                 pkc->pubkey_algo, last_pk->pubkey_algo );
381                 else {
382                     copy_public_cert( pkc, last_pk );
383                     goto leave;
384                 }
385             }
386         }
387         else if( !keyid && !name && pkt.pkttype == PKT_PUBLIC_CERT ) {
388             if( last_pk )
389                 free_public_cert(last_pk);
390             last_pk = pkt.pkt.public_cert;
391             pkt.pkt.public_cert = NULL;
392         }
393         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
394             if( !last_pk )
395                 log_error("Ooops: no pubkey for userid '%.*s'\n",
396                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
397             else {
398                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
399                     || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
400                      keyid_from_pkc( last_pk, akeyid );
401                      cache_user_id( pkt.pkt.user_id, akeyid );
402                 }
403                 cache_public_cert( last_pk );
404             }
405         }
406         free_packet(&pkt);
407     }
408     rc = G10ERR_NO_PUBKEY;
409
410   leave:
411     if( last_pk )
412         free_public_cert(last_pk);
413     free_packet(&pkt);
414     iobuf_close(a);
415     set_packet_list_mode(save_mode);
416     return rc;
417 }
418
419
420 /****************
421  * This is the function to get a secret key. We use an extra function,
422  * so that we can easily add special handling for secret keyrings
423  * PKT returns the secret key certificate.
424  */
425 static int
426 scan_secret_keyring( PKT_secret_cert *skc, u32 *keyid,
427                      const char *name, const char *filename )
428 {
429     int rc=0;
430     int found = 0;
431     IOBUF a;
432     PACKET pkt;
433     int save_mode;
434     u32 akeyid[2];
435     PKT_secret_cert *last_pk = NULL;
436     int get_first;
437     u32 dummy_keyid[2];
438
439     get_first = !keyid && !name;
440     if( get_first )
441         keyid = dummy_keyid;
442
443     if( !(a = iobuf_open( filename ) ) ) {
444         log_debug("scan_secret_keyring: can't open '%s'\n", filename );
445         return G10ERR_KEYRING_OPEN;
446     }
447
448     save_mode = set_packet_list_mode(0);
449     init_packet(&pkt);
450     while( (rc=parse_packet(a, &pkt)) != -1 ) {
451         if( rc )
452             ; /* e.g. unknown packet */
453         else if( keyid && found && pkt.pkttype == PKT_SECRET_CERT ) {
454             log_error("Hmmm, seckey without an user id in '%s'\n", filename);
455             goto leave;
456         }
457         else if( keyid && pkt.pkttype == PKT_SECRET_CERT ) {
458             switch( pkt.pkt.secret_cert->pubkey_algo ) {
459               case PUBKEY_ALGO_ELGAMAL:
460               case PUBKEY_ALGO_RSA:
461                 if( get_first ) {
462                     copy_secret_cert( skc, pkt.pkt.secret_cert );
463                     found++;
464                 }
465                 else {
466                     keyid_from_skc( pkt.pkt.secret_cert, akeyid );
467                     if( (akeyid[0] == keyid[0] && akeyid[1] == keyid[1]) ) {
468                         copy_secret_cert( skc, pkt.pkt.secret_cert );
469                         found++;
470                     }
471                 }
472                 break;
473               default:
474                 log_error("cannot handle pubkey algo %d\n",
475                                      pkt.pkt.secret_cert->pubkey_algo);
476             }
477         }
478         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
479             goto leave;
480         }
481         else if( name && pkt.pkttype == PKT_SECRET_CERT ) {
482             if( last_pk )
483                 free_secret_cert(last_pk);
484             last_pk = pkt.pkt.secret_cert;
485             pkt.pkt.secret_cert = NULL;
486         }
487         else if( name && pkt.pkttype == PKT_USER_ID ) {
488             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
489                 if( !last_pk )
490                     log_error("Ooops: no seckey for userid '%.*s'\n",
491                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
492                 else if( skc->pubkey_algo &&
493                          skc->pubkey_algo != last_pk->pubkey_algo )
494                     log_info("skipping id '%.*s': want algo %d, found %d\n",
495                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
496                                 skc->pubkey_algo, last_pk->pubkey_algo );
497                 else {
498                     copy_secret_cert( skc, last_pk );
499                     goto leave;
500                 }
501             }
502         }
503         else if( !keyid && !name && pkt.pkttype == PKT_SECRET_CERT ) {
504             if( last_pk )
505                 free_secret_cert(last_pk);
506             last_pk = pkt.pkt.secret_cert;
507             pkt.pkt.secret_cert = NULL;
508         }
509         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
510             if( !last_pk )
511                 log_error("Ooops: no seckey for userid '%.*s'\n",
512                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
513             else {
514                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
515                    || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
516                     keyid_from_skc( last_pk, akeyid );
517                     cache_user_id( pkt.pkt.user_id, akeyid );
518                 }
519             }
520         }
521         free_packet(&pkt);
522     }
523     rc = G10ERR_NO_SECKEY;
524
525   leave:
526     if( last_pk )
527         free_secret_cert(last_pk);
528     free_packet(&pkt);
529     iobuf_close(a);
530     set_packet_list_mode(save_mode);
531     return rc;
532 }
533
534
535 /****************
536  * Return a string with a printable representation of the user_id.
537  * this string must be freed by m_free.
538  */
539 char*
540 get_user_id_string( u32 *keyid )
541 {
542     user_id_db_t r;
543     char *p;
544     int pass=0;
545     /* try it two times; second pass reads from keyrings */
546     do {
547         for(r=user_id_db; r; r = r->next )
548             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
549                 p = m_alloc( r->len + 10 );
550                 sprintf(p, "%08lX %.*s", keyid[1], r->len, r->name );
551                 return p;
552             }
553     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
554     p = m_alloc( 15 );
555     sprintf(p, "%08lX [?]", keyid[1] );
556     return p;
557 }
558
559 char*
560 get_user_id( u32 *keyid, size_t *rn )
561 {
562     user_id_db_t r;
563     char *p;
564     int pass=0;
565     /* try it two times; second pass reads from keyrings */
566     do {
567         for(r=user_id_db; r; r = r->next )
568             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
569                 p = m_alloc( r->len );
570                 memcpy(p, r->name, r->len );
571                 *rn = r->len;
572                 return p;
573             }
574     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
575     p = m_alloc( 19 );
576     memcpy(p, "[User id not found]", 19 );
577     *rn = 19;
578     return p;
579 }
580
581