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