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