added some stuff for signing keys
[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, 0 );
87     if( rc )
88         log_error("keyblock resource '%s': %s\n", name, g10_errstr(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_byname( 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_byname( PKT_secret_cert *skc, const char *name, int unprotect )
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( unprotect )
323         if( (rc = check_secret_key( skc )) )
324             goto leave;
325
326   leave:
327     return rc;
328 }
329
330
331 /****************
332  * scan the keyring and look for either the keyid or the name.
333  */
334 static int
335 scan_keyring( PKT_public_cert *pkc, u32 *keyid,
336               const char *name, const char *filename )
337 {
338     int rc=0;
339     int found = 0;
340     IOBUF a;
341     PACKET pkt;
342     int save_mode;
343     u32 akeyid[2];
344     PKT_public_cert *last_pk = NULL;
345
346     assert( !keyid || !name );
347
348     if( opt.cache_all && (name || keyid) )
349         return G10ERR_NO_PUBKEY;
350
351     if( !(a = iobuf_open( filename ) ) ) {
352         log_debug("scan_keyring: can't open '%s'\n", filename );
353         return G10ERR_KEYRING_OPEN;
354     }
355
356     if( !DBG_CACHE )
357         ;
358     else if( name )
359         log_debug("scan_keyring %s for '%s'\n",  filename, name );
360     else if( keyid )
361         log_debug("scan_keyring %s for %08lx %08lx\n",  filename,
362                                                 keyid[0], keyid[1] );
363     else
364         log_debug("scan_keyring %s (all)\n",  filename );
365
366     save_mode = set_packet_list_mode(0);
367     init_packet(&pkt);
368     while( (rc=parse_packet(a, &pkt)) != -1 ) {
369         if( rc )
370             ; /* e.g. unknown packet */
371         else if( keyid && found && pkt.pkttype == PKT_PUBLIC_CERT ) {
372             log_error("Hmmm, pubkey without an user id in '%s'\n", filename);
373             goto leave;
374         }
375         else if( keyid && pkt.pkttype == PKT_PUBLIC_CERT ) {
376             switch( pkt.pkt.public_cert->pubkey_algo ) {
377               case PUBKEY_ALGO_ELGAMAL:
378               case PUBKEY_ALGO_RSA:
379                 keyid_from_pkc( pkt.pkt.public_cert, akeyid );
380                 if( akeyid[0] == keyid[0] && akeyid[1] == keyid[1] ) {
381                     copy_public_cert( pkc, pkt.pkt.public_cert );
382                     found++;
383                 }
384                 break;
385               default:
386                 log_error("cannot handle pubkey algo %d\n",
387                                      pkt.pkt.public_cert->pubkey_algo);
388             }
389         }
390         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
391             cache_user_id( pkt.pkt.user_id, keyid );
392             goto leave;
393         }
394         else if( name && pkt.pkttype == PKT_PUBLIC_CERT ) {
395             if( last_pk )
396                 free_public_cert(last_pk);
397             last_pk = pkt.pkt.public_cert;
398             pkt.pkt.public_cert = NULL;
399         }
400         else if( name && pkt.pkttype == PKT_USER_ID ) {
401             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
402                 if( !last_pk )
403                     log_error("Ooops: no pubkey for userid '%.*s'\n",
404                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
405                 else if( pkc->pubkey_algo &&
406                          pkc->pubkey_algo != last_pk->pubkey_algo )
407                     log_info("skipping id '%.*s': want algo %d, found %d\n",
408                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
409                                 pkc->pubkey_algo, last_pk->pubkey_algo );
410                 else {
411                     copy_public_cert( pkc, last_pk );
412                     goto leave;
413                 }
414             }
415         }
416         else if( !keyid && !name && pkt.pkttype == PKT_PUBLIC_CERT ) {
417             if( last_pk )
418                 free_public_cert(last_pk);
419             last_pk = pkt.pkt.public_cert;
420             pkt.pkt.public_cert = NULL;
421         }
422         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
423             if( !last_pk )
424                 log_error("Ooops: no pubkey for userid '%.*s'\n",
425                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
426             else {
427                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
428                     || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
429                      keyid_from_pkc( last_pk, akeyid );
430                      cache_user_id( pkt.pkt.user_id, akeyid );
431                 }
432                 cache_public_cert( last_pk );
433             }
434         }
435         free_packet(&pkt);
436     }
437     rc = G10ERR_NO_PUBKEY;
438
439   leave:
440     if( last_pk )
441         free_public_cert(last_pk);
442     free_packet(&pkt);
443     iobuf_close(a);
444     set_packet_list_mode(save_mode);
445     return rc;
446 }
447
448
449 /****************
450  * This is the function to get a secret key. We use an extra function,
451  * so that we can easily add special handling for secret keyrings
452  * PKT returns the secret key certificate.
453  */
454 static int
455 scan_secret_keyring( PKT_secret_cert *skc, u32 *keyid,
456                      const char *name, const char *filename )
457 {
458     int rc=0;
459     int found = 0;
460     IOBUF a;
461     PACKET pkt;
462     int save_mode;
463     u32 akeyid[2];
464     PKT_secret_cert *last_pk = NULL;
465     int get_first;
466     u32 dummy_keyid[2];
467
468     get_first = !keyid && !name;
469     if( get_first )
470         keyid = dummy_keyid;
471
472     if( !(a = iobuf_open( filename ) ) ) {
473         log_debug("scan_secret_keyring: can't open '%s'\n", filename );
474         return G10ERR_KEYRING_OPEN;
475     }
476
477     save_mode = set_packet_list_mode(0);
478     init_packet(&pkt);
479     while( (rc=parse_packet(a, &pkt)) != -1 ) {
480         if( rc )
481             ; /* e.g. unknown packet */
482         else if( keyid && found && pkt.pkttype == PKT_SECRET_CERT ) {
483             log_error("Hmmm, seckey without an user id in '%s'\n", filename);
484             goto leave;
485         }
486         else if( keyid && pkt.pkttype == PKT_SECRET_CERT ) {
487             switch( pkt.pkt.secret_cert->pubkey_algo ) {
488               case PUBKEY_ALGO_ELGAMAL:
489               case PUBKEY_ALGO_RSA:
490                 if( get_first ) {
491                     copy_secret_cert( skc, pkt.pkt.secret_cert );
492                     found++;
493                 }
494                 else {
495                     keyid_from_skc( pkt.pkt.secret_cert, akeyid );
496                     if( (akeyid[0] == keyid[0] && akeyid[1] == keyid[1]) ) {
497                         copy_secret_cert( skc, pkt.pkt.secret_cert );
498                         found++;
499                     }
500                 }
501                 break;
502               default:
503                 log_error("cannot handle pubkey algo %d\n",
504                                      pkt.pkt.secret_cert->pubkey_algo);
505             }
506         }
507         else if( keyid && found && pkt.pkttype == PKT_USER_ID ) {
508             goto leave;
509         }
510         else if( name && pkt.pkttype == PKT_SECRET_CERT ) {
511             if( last_pk )
512                 free_secret_cert(last_pk);
513             last_pk = pkt.pkt.secret_cert;
514             pkt.pkt.secret_cert = NULL;
515         }
516         else if( name && pkt.pkttype == PKT_USER_ID ) {
517             if( memistr( pkt.pkt.user_id->name, pkt.pkt.user_id->len, name )) {
518                 if( !last_pk )
519                     log_error("Ooops: no seckey for userid '%.*s'\n",
520                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name);
521                 else if( skc->pubkey_algo &&
522                          skc->pubkey_algo != last_pk->pubkey_algo )
523                     log_info("skipping id '%.*s': want algo %d, found %d\n",
524                                 pkt.pkt.user_id->len, pkt.pkt.user_id->name,
525                                 skc->pubkey_algo, last_pk->pubkey_algo );
526                 else {
527                     copy_secret_cert( skc, last_pk );
528                     goto leave;
529                 }
530             }
531         }
532         else if( !keyid && !name && pkt.pkttype == PKT_SECRET_CERT ) {
533             if( last_pk )
534                 free_secret_cert(last_pk);
535             last_pk = pkt.pkt.secret_cert;
536             pkt.pkt.secret_cert = NULL;
537         }
538         else if( !keyid && !name && pkt.pkttype == PKT_USER_ID ) {
539             if( !last_pk )
540                 log_error("Ooops: no seckey for userid '%.*s'\n",
541                             pkt.pkt.user_id->len, pkt.pkt.user_id->name);
542             else {
543                 if( last_pk->pubkey_algo == PUBKEY_ALGO_ELGAMAL
544                    || last_pk->pubkey_algo == PUBKEY_ALGO_RSA ) {
545                     keyid_from_skc( last_pk, akeyid );
546                     cache_user_id( pkt.pkt.user_id, akeyid );
547                 }
548             }
549         }
550         free_packet(&pkt);
551     }
552     rc = G10ERR_NO_SECKEY;
553
554   leave:
555     if( last_pk )
556         free_secret_cert(last_pk);
557     free_packet(&pkt);
558     iobuf_close(a);
559     set_packet_list_mode(save_mode);
560     return rc;
561 }
562
563
564 /****************
565  * Return a string with a printable representation of the user_id.
566  * this string must be freed by m_free.
567  */
568 char*
569 get_user_id_string( u32 *keyid )
570 {
571     user_id_db_t r;
572     char *p;
573     int pass=0;
574     /* try it two times; second pass reads from keyrings */
575     do {
576         for(r=user_id_db; r; r = r->next )
577             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
578                 p = m_alloc( r->len + 10 );
579                 sprintf(p, "%08lX %.*s", keyid[1], r->len, r->name );
580                 return p;
581             }
582     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
583     p = m_alloc( 15 );
584     sprintf(p, "%08lX [?]", keyid[1] );
585     return p;
586 }
587
588 char*
589 get_user_id( u32 *keyid, size_t *rn )
590 {
591     user_id_db_t r;
592     char *p;
593     int pass=0;
594     /* try it two times; second pass reads from keyrings */
595     do {
596         for(r=user_id_db; r; r = r->next )
597             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
598                 p = m_alloc( r->len );
599                 memcpy(p, r->name, r->len );
600                 *rn = r->len;
601                 return p;
602             }
603     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
604     p = m_alloc( 19 );
605     memcpy(p, "[User id not found]", 19 );
606     *rn = 19;
607     return p;
608 }
609
610