nearly ready for 0.3.0
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG 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  * GNUPG 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 <ctype.h>
27 #include "util.h"
28 #include "packet.h"
29 #include "memory.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "options.h"
33 #include "main.h"
34
35 #define MAX_PKC_CACHE_ENTRIES 500
36
37
38 typedef struct keyid_list {
39     struct keyid_list *next;
40     u32 keyid[2];
41 } *keyid_list_t;
42
43 typedef struct user_id_db {
44     struct user_id_db *next;
45     u32 keyid[2];
46     int len;
47     char name[1];
48 } *user_id_db_t;
49
50 typedef struct pkc_cache_entry {
51     struct pkc_cache_entry *next;
52     u32 keyid[2];
53     PKT_public_cert *pkc;
54 } *pkc_cache_entry_t;
55
56 typedef struct enum_seckey_context {
57     int eof;
58     STRLIST sl;
59     IOBUF iobuf;
60 } enum_seckey_context_t;
61
62
63 static STRLIST keyrings;
64 static STRLIST secret_keyrings;
65
66 static keyid_list_t unknown_keyids;
67 static user_id_db_t user_id_db;
68 static pkc_cache_entry_t pkc_cache;
69 static int pkc_cache_entries;   /* number of entries in pkc cache */
70
71
72 static int lookup( PKT_public_cert *pkc,
73                    int mode,  u32 *keyid, const char *name,
74                    KBNODE *ret_keyblock  );
75 static int lookup_skc( PKT_secret_cert *skc,
76                    int mode,  u32 *keyid, const char *name );
77
78 /* note this function may be called before secure memory is
79  * available */
80 void
81 add_keyring( const char *name )
82 {
83     STRLIST sl;
84     int rc;
85
86     if( *name != '/' ) { /* do tilde expansion etc */
87         char *p ;
88
89         if( strchr(name, '/') )
90             p = make_filename(name, NULL);
91         else
92             p = make_filename(opt.homedir, name, NULL);
93         sl = m_alloc( sizeof *sl + strlen(p) );
94         strcpy(sl->d, p );
95         m_free(p);
96     }
97     else {
98         sl = m_alloc( sizeof *sl + strlen(name) );
99         strcpy(sl->d, name );
100     }
101     sl->next = keyrings;
102     keyrings = sl;
103
104     /* fixme: We should remove much out of this module and
105      * combine it with the keyblock stuff from ringedit.c
106      * For now we will simple add the filename as keyblock resource
107      */
108     rc = add_keyblock_resource( sl->d, 0, 0 );
109     if( rc )
110         log_error("keyblock resource '%s': %s\n", sl->d, g10_errstr(rc) );
111 }
112
113
114 /****************
115  * Get the name of the keyrings, start with a sequence number of 0.
116  */
117 const char *
118 get_keyring( int sequence )
119 {
120     STRLIST sl;
121
122     for(sl = keyrings; sl && sequence; sl = sl->next, sequence-- )
123         ;
124     return sl? sl->d : NULL;
125 }
126
127 const char *
128 get_secret_keyring( int sequence )
129 {
130     STRLIST sl;
131
132     for(sl = secret_keyrings; sl && sequence; sl = sl->next, sequence-- )
133         ;
134     return sl? sl->d : NULL;
135 }
136
137
138 void
139 add_secret_keyring( const char *name )
140 {
141     STRLIST sl;
142     int rc;
143
144     if( *name != '/' ) { /* do tilde expansion etc */
145         char *p ;
146
147         if( strchr(name, '/') )
148             p = make_filename(name, NULL);
149         else
150             p = make_filename(opt.homedir, name, NULL);
151         sl = m_alloc( sizeof *sl + strlen(p) );
152         strcpy(sl->d, p );
153         m_free(p);
154     }
155     else {
156         sl = m_alloc( sizeof *sl + strlen(name) );
157         strcpy(sl->d, name );
158     }
159     sl->next = secret_keyrings;
160     secret_keyrings = sl;
161
162     /* fixme: We should remove much out of this module and
163      * combine it with the keyblock stuff from ringedit.c
164      * For now we will simple add the filename as keyblock resource
165      */
166     rc = add_keyblock_resource( sl->d, 0, 1 );
167     if( rc )
168         log_error("secret keyblock resource '%s': %s\n", sl->d, g10_errstr(rc));
169 }
170
171
172 static void
173 cache_public_cert( PKT_public_cert *pkc )
174 {
175     pkc_cache_entry_t ce;
176     u32 keyid[2];
177
178     if( is_ELGAMAL(pkc->pubkey_algo)
179         || pkc->pubkey_algo == PUBKEY_ALGO_DSA
180         || is_RSA(pkc->pubkey_algo) ) {
181         keyid_from_pkc( pkc, keyid );
182     }
183     else
184         return; /* don't know how to get the keyid */
185
186     for( ce = pkc_cache; ce; ce = ce->next )
187         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
188             if( DBG_CACHE )
189                 log_debug("cache_public_cert: already in cache\n");
190             return;
191         }
192
193     if( pkc_cache_entries > MAX_PKC_CACHE_ENTRIES ) {
194         /* FIMXE: use another algorithm to free some cache slots */
195         if( pkc_cache_entries == MAX_PKC_CACHE_ENTRIES )  {
196             pkc_cache_entries++;
197             log_info("too many entries in pkc cache - disabled\n");
198         }
199         ce = pkc_cache;
200         free_public_cert( ce->pkc );
201     }
202     else {
203         pkc_cache_entries++;
204         ce = m_alloc( sizeof *ce );
205         ce->next = pkc_cache;
206         pkc_cache = ce;
207     }
208     ce->pkc = copy_public_cert( NULL, pkc );
209     ce->keyid[0] = keyid[0];
210     ce->keyid[1] = keyid[1];
211 }
212
213
214 /****************
215  * Store the association of keyid and userid
216  */
217 void
218 cache_user_id( PKT_user_id *uid, u32 *keyid )
219 {
220     user_id_db_t r;
221
222     for(r=user_id_db; r; r = r->next )
223         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
224             if( DBG_CACHE )
225                log_debug("cache_user_id: already in cache\n");
226             return;
227         }
228
229     r = m_alloc( sizeof *r + uid->len-1 );
230     r->keyid[0] = keyid[0];
231     r->keyid[1] = keyid[1];
232     r->len = uid->len;
233     memcpy(r->name, uid->name, r->len);
234     r->next = user_id_db;
235     user_id_db = r;
236 }
237
238
239
240 /****************
241  * Get a public key and store it into the allocated pkc
242  * can be called with PKC set to NULL to just read it into some
243  * internal structures.
244  */
245 int
246 get_pubkey( PKT_public_cert *pkc, u32 *keyid )
247 {
248     keyid_list_t kl;
249     int internal = 0;
250     int rc = 0;
251     pkc_cache_entry_t ce;
252
253     /* let's see whether we checked the keyid already */
254     for( kl = unknown_keyids; kl; kl = kl->next )
255         if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
256             return G10ERR_NO_PUBKEY; /* already checked and not found */
257
258     /* Try to get it from our cache */
259     for( ce = pkc_cache; ce; ce = ce->next )
260         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
261             if( pkc )
262                 copy_public_cert( pkc, ce->pkc );
263             return 0;
264         }
265     /* more init stuff */
266     if( !pkc ) {
267         pkc = m_alloc_clear( sizeof *pkc );
268         internal++;
269     }
270
271
272     /* do a lookup */
273     rc = lookup( pkc, 11, keyid, NULL, NULL );
274     if( !rc )
275         goto leave;
276
277     /* not found: store it for future reference */
278     kl = m_alloc( sizeof *kl );
279     kl->keyid[0] = keyid[0];
280     kl->keyid[1] = keyid[1];
281     kl->next = unknown_keyids;
282     unknown_keyids = kl;
283     rc = G10ERR_NO_PUBKEY;
284
285   leave:
286     if( !rc )
287         cache_public_cert( pkc );
288     if( internal )
289         m_free(pkc);
290     return rc;
291 }
292
293
294 static int
295 hextobyte( const byte *s )
296 {
297     int c;
298
299     if( *s >= '0' && *s <= '9' )
300         c = 16 * (*s - '0');
301     else if( *s >= 'A' && *s <= 'F' )
302         c = 16 * (10 + *s - 'A');
303     else if( *s >= 'a' && *s <= 'f' )
304         c = 16 * (10 + *s - 'a');
305     else
306         return -1;
307     s++;
308     if( *s >= '0' && *s <= '9' )
309         c += *s - '0';
310     else if( *s >= 'A' && *s <= 'F' )
311         c += 10 + *s - 'A';
312     else if( *s >= 'a' && *s <= 'f' )
313         c += 10 + *s - 'a';
314     else
315         return -1;
316     return c;
317 }
318
319
320 /****************
321  * Try to get the pubkey by the userid. This function looks for the
322  * first pubkey certificate which has the given name in a user_id.
323  * if pkc has the pubkey algo set, the function will only return
324  * a pubkey with that algo.
325  *
326  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
327  *   must be in the range 0..9), this is considered a keyid; depending
328  *   on the length a short or complete one.
329  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
330  *   must be in the range 0..9), this is considered a fingerprint.
331  *   (Not yet implemented)
332  * - If the username starts with a left angle, we assume it is a complete
333  *   email address and look only at this part.
334  * - If the username starts with a '.', we assume it is the ending
335  *   part of an email address
336  * - If the username starts with an '@', we assume it is a part of an
337  *   email address
338  * - If the userid start with an '=' an exact compare is done; this may
339  *   also follow the keyid in which case both parts are matched.
340  * - If the userid starts with a '*' a case insensitive substring search is
341  *   done (This is also the default).
342  */
343
344
345 static int
346 key_byname( int secret,
347             PKT_public_cert *pkc, PKT_secret_cert *skc, const char *name )
348 {
349     int internal = 0;
350     int rc = 0;
351     const char *s;
352     u32 keyid[2] = {0}; /* init to avoid compiler warning */
353     byte fprint[20];
354     int mode = 0;
355
356     /* check what kind of name it is */
357     for(s = name; *s && isspace(*s); s++ )
358         ;
359     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
360         int i, j;
361         char buf[9];
362
363         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
364             s += 2; /*kludge to allow 0x034343434 */
365         for(i=0; isxdigit(s[i]); i++ )
366             ;
367         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
368             rc = G10ERR_INV_USER_ID;
369         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
370             if( i==9 )
371                 s++;
372             keyid[1] = strtoul( s, NULL, 16 );
373             mode = 10;
374         }
375         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
376             if( i==17 )
377                 s++;
378             mem2str(buf, s, 9 );
379             keyid[0] = strtoul( buf, NULL, 16 );
380             keyid[1] = strtoul( s+8, NULL, 16 );
381             mode = 11;
382         }
383         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
384             if( i==33 )
385                 s++;
386             memset(fprint+16, 4, 0);
387             for(j=0; !rc && j < 16; j++, s+=2 ) {
388                 int c = hextobyte( s );
389                 if( c == -1 )
390                     rc = G10ERR_INV_USER_ID;
391                 else
392                     fprint[j] = c;
393             }
394             mode = 16;
395         }
396         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
397             if( i==33 )
398                 s++;
399             for(j=0; !rc && j < 20; j++, s+=2 ) {
400                 int c = hextobyte( s );
401                 if( c == -1 )
402                     rc = G10ERR_INV_USER_ID;
403                 else
404                     fprint[j] = c;
405             }
406             mode = 20;
407         }
408         else
409             rc = G10ERR_INV_USER_ID;
410     }
411     else if( *s == '=' ) { /* exact search */
412         mode = 1;
413         s++;
414     }
415     else if( *s == '*' ) { /* substring search */
416         mode = 2;
417         s++;
418     }
419     else if( *s == '<' ) { /* an email address */
420         mode = 3;
421     }
422     else if( *s == '@' ) { /* a part of an email address */
423         mode = 4;
424         s++;
425     }
426     else if( *s == '.' ) { /* an email address, compare from end */
427         mode = 5;
428         s++;
429     }
430     else if( *s == '#' ) { /* use local id */
431         rc = G10ERR_INV_USER_ID; /* not yet implemented */
432     }
433     else if( !*s )  /* empty string */
434         rc = G10ERR_INV_USER_ID;
435     else
436         mode = 2;
437
438     if( rc )
439         goto leave;
440
441     if( secret ) {
442         if( !skc ) {
443             skc = m_alloc_clear( sizeof *skc );
444             internal++;
445         }
446         rc = mode < 16? lookup_skc( skc, mode, keyid, name )
447                       : lookup_skc( skc, mode, keyid, fprint );
448     }
449     else {
450         if( !pkc ) {
451             pkc = m_alloc_clear( sizeof *pkc );
452             internal++;
453         }
454         rc = mode < 16? lookup( pkc, mode, keyid, name, NULL )
455                       : lookup( pkc, mode, keyid, fprint, NULL );
456     }
457
458
459   leave:
460     if( internal && secret )
461         m_free( skc );
462     else if( internal )
463         m_free( pkc );
464     return rc;
465 }
466
467 int
468 get_pubkey_byname( PKT_public_cert *pkc, const char *name )
469 {
470     return key_byname( 0, pkc, NULL, name );
471 }
472
473
474
475 /****************
476  * Search for a key with the given fingerprint and return the
477  * complete keyblock which may have more than only this key.
478  */
479 int
480 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
481                                                 size_t fprint_len )
482 {
483     int rc;
484     PKT_public_cert *pkc = m_alloc_clear( sizeof *pkc );
485
486     if( fprint_len == 20 || fprint_len == 16 )
487         rc = lookup( pkc, fprint_len, NULL, fprint, ret_keyblock );
488     else
489         rc = G10ERR_GENERAL; /* Oops */
490
491     free_public_cert( pkc );
492     return rc;
493 }
494
495 /****************
496  * Get a secret key and store it into skc
497  */
498 int
499 get_seckey( PKT_secret_cert *skc, u32 *keyid )
500 {
501     int rc;
502
503     rc = lookup_skc( skc, 11, keyid, NULL );
504     if( !rc ) {
505         /* check the secret key (this may prompt for a passprase to
506          * unlock the secret key
507          */
508         rc = check_secret_key( skc );
509     }
510
511     return rc;
512 }
513
514 /****************
515  * Check whether the secret key is available
516  * Returns: 0 := key is available
517  *          G10ERR_NO_SECKEY := not availabe
518  */
519 int
520 seckey_available( u32 *keyid )
521 {
522     PKT_secret_cert *skc;
523     int rc;
524
525     skc = m_alloc_clear( sizeof *skc );
526     rc = lookup_skc( skc, 11, keyid, NULL );
527     free_secret_cert( skc );
528     return rc;
529 }
530
531
532
533 /****************
534  * Get a secret key by name and store it into skc
535  * If NAME is NULL use the default certificate
536  */
537 int
538 get_seckey_byname( PKT_secret_cert *skc, const char *name, int unprotect )
539 {
540     int rc;
541
542     rc = name ? key_byname( 1, NULL, skc, name )
543               : lookup_skc( skc, 15, NULL, NULL );
544     if( !rc && unprotect )
545         rc = check_secret_key( skc );
546
547     return rc;
548 }
549
550
551 static int
552 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
553 {
554     int i;
555     const char *s, *se;
556
557     if( mode == 1 ) {  /* exact match */
558         for(i=0; name[i] && uidlen; i++, uidlen-- )
559             if( uid[i] != name[i] )
560                 break;
561         if( !uidlen && !name[i] )
562             return 0; /* found */
563     }
564     else if( mode == 2 ) { /* case insensitive substring */
565         if( memistr( uid, uidlen, name ) )
566             return 0;
567     }
568     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
569         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
570             ;
571         if( i < uidlen )  {
572             /* skip opening delim and one char and look for the closing one*/
573             s++; i++;
574             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
575                 ;
576             if( i < uidlen ) {
577                 i = se - s;
578                 if( mode == 3 ) { /* exact email address */
579                     if( strlen(name) == i && !memicmp( s, name, i) )
580                         return 0;
581                 }
582                 else if( mode == 4 ) {  /* email substring */
583                     if( memistr( s, i, name ) )
584                         return 0;
585                 }
586                 else { /* email from end */
587                     /* nyi */
588                 }
589             }
590         }
591     }
592     else
593         BUG();
594
595     return -1; /* not found */
596 }
597
598
599
600 /****************
601  * Assume that knode points to a public key packet  and keyblock is
602  * the entire keyblock.  This function adds all relevant information from
603  * a selfsignature to the public key.
604  */
605
606 static void
607 add_stuff_from_selfsig( KBNODE keyblock, KBNODE knode )
608 {
609     PKT_public_cert *pkc = knode->pkt->pkt.public_cert;
610     PKT_signature *sig;
611     KBNODE k;
612     u32 kid[2];
613
614     assert(    knode->pkt->pkttype == PKT_PUBLIC_CERT
615             || knode->pkt->pkttype == PKT_PUBKEY_SUBCERT );
616
617     if( pkc->version < 4 )
618         return; /* this is only needed for version >=4 packets */
619
620     /* find the selfsignature */
621     if( knode->pkt->pkttype == PKT_PUBKEY_SUBCERT ) {
622         k = find_kbnode( keyblock, PKT_PUBLIC_CERT );
623         if( !k )
624            BUG(); /* keyblock without primary key!!! */
625         keyid_from_pkc( knode->pkt->pkt.public_cert, kid );
626     }
627     else
628         keyid_from_pkc( pkc, kid );
629     for(k=keyblock; k; k = k->next ) {
630         if( k->pkt->pkttype == PKT_SIGNATURE
631             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
632             && sig->sig_class <= 0x13
633             && sig->keyid[0] == kid[0]
634             && sig->keyid[1] == kid[1]
635             && sig->version > 3 ) {
636             /* okay this is (the first) self-signature which can be used
637              * fixme: Check how to handle subkey bindings
638              * FIXME: We should only use this if the signature is valid
639              *        but this is time consuming - we muts provide another
640              *        way to handle this
641              */
642             const byte *p;
643             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
644             pkc->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
645             /* fixme: add usage etc. to pkc */
646             break;
647         }
648     }
649 }
650
651 /****************
652  * Lookup a key by scanning all keyrings
653  *   mode 1 = lookup by NAME (exact)
654  *        2 = lookup by NAME (substring)
655  *        3 = lookup by NAME (email address)
656  *        4 = email address (substring)
657  *        5 = email address (compare from end)
658  *       10 = lookup by short KEYID (don't care about keyid[0])
659  *       11 = lookup by long  KEYID
660  *       15 = Get the first key.
661  *       16 = lookup by 16 byte fingerprint which is stored in NAME
662  *       20 = lookup by 20 byte fingerprint which is stored in NAME
663  * Caller must provide an empty PKC, if the pubkey_algo is filled in, only
664  * a key of this algo will be returned.
665  * If ret_keyblock is not NULL, the complete keyblock is returned also
666  * and the caller must release it.
667  */
668 static int
669 lookup( PKT_public_cert *pkc, int mode,  u32 *keyid,
670         const char *name, KBNODE *ret_keyblock )
671 {
672     int rc;
673     KBNODE keyblock = NULL;
674     KBPOS kbpos;
675     int oldmode = set_packet_list_mode(0);
676
677     rc = enum_keyblocks( 0, &kbpos, &keyblock );
678     if( rc ) {
679         if( rc == -1 )
680             rc = G10ERR_NO_PUBKEY;
681         else if( rc )
682             log_error("enum_keyblocks(open) failed: %s\n", g10_errstr(rc) );
683         goto leave;
684     }
685
686     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
687         KBNODE k, kk;
688         if( mode < 10 ) { /* name lookup */
689             for(k=keyblock; k; k = k->next ) {
690                 if( k->pkt->pkttype == PKT_USER_ID
691                     && !compare_name( k->pkt->pkt.user_id->name,
692                                       k->pkt->pkt.user_id->len, name, mode)) {
693                     /* we found a matching name, look for the key */
694                     for(kk=keyblock; kk; kk = kk->next )
695                         if( (    kk->pkt->pkttype == PKT_PUBLIC_CERT
696                               || kk->pkt->pkttype == PKT_PUBKEY_SUBCERT )
697                             && ( !pkc->pubkey_algo
698                                  || pkc->pubkey_algo
699                                     == kk->pkt->pkt.public_cert->pubkey_algo))
700                         break;
701                     if( kk ) {
702                         u32 aki[2];
703                         keyid_from_pkc( kk->pkt->pkt.public_cert, aki );
704                         cache_user_id( k->pkt->pkt.user_id, aki );
705                         k = kk;
706                         break;
707                     }
708                     else
709                         log_error("No key for userid\n");
710                 }
711             }
712         }
713         else { /* keyid or fingerprint lookup */
714             if( DBG_CACHE && (mode== 10 || mode==11) ) {
715                 log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
716                                 (ulong)keyid[0], (ulong)keyid[1],
717                                  pkc->pubkey_algo, mode );
718             }
719             for(k=keyblock; k; k = k->next ) {
720                 if(    k->pkt->pkttype == PKT_PUBLIC_CERT
721                     || k->pkt->pkttype == PKT_PUBKEY_SUBCERT ) {
722                     if( mode == 10 || mode == 11 ) {
723                         u32 aki[2];
724                         keyid_from_pkc( k->pkt->pkt.public_cert, aki );
725                         if( DBG_CACHE ) {
726                             log_debug("         aki=%08lx%08lx algo=%d\n",
727                                             (ulong)aki[0], (ulong)aki[1],
728                                     k->pkt->pkt.public_cert->pubkey_algo    );
729                         }
730                         if( aki[1] == keyid[1]
731                             && ( mode == 10 || aki[0] == keyid[0] )
732                             && ( !pkc->pubkey_algo
733                                  || pkc->pubkey_algo
734                                     == k->pkt->pkt.public_cert->pubkey_algo) ){
735                             /* cache the userid */
736                             for(kk=keyblock; kk; kk = kk->next )
737                                 if( kk->pkt->pkttype == PKT_USER_ID )
738                                     break;
739                             if( kk )
740                                 cache_user_id( kk->pkt->pkt.user_id, aki );
741                             else
742                                 log_error("No userid for key\n");
743                             break; /* found */
744                         }
745                     }
746                     else if( mode == 15 ) { /* get the first key */
747                         if( !pkc->pubkey_algo
748                             || pkc->pubkey_algo
749                                   == k->pkt->pkt.public_cert->pubkey_algo )
750                             break;
751                     }
752                     else if( mode == 16 || mode == 20 ) {
753                         size_t an;
754                         byte *afp = fingerprint_from_pkc(
755                                         k->pkt->pkt.public_cert, &an );
756                         if( an == mode && !memcmp( afp, name, an)
757                             && ( !pkc->pubkey_algo
758                                  || pkc->pubkey_algo
759                                     == k->pkt->pkt.public_cert->pubkey_algo) ) {
760                             m_free(afp);
761                             break;
762                         }
763                         m_free(afp);
764                     }
765                     else
766                         BUG();
767                 } /* end compare public keys */
768             }
769         }
770         if( k ) { /* found */
771             assert(    k->pkt->pkttype == PKT_PUBLIC_CERT
772                     || k->pkt->pkttype == PKT_PUBKEY_SUBCERT );
773             copy_public_cert( pkc, k->pkt->pkt.public_cert );
774             add_stuff_from_selfsig( keyblock, k );
775             if( ret_keyblock ) {
776                 *ret_keyblock = keyblock;
777                 keyblock = NULL;
778             }
779             break; /* enumeration */
780         }
781         release_kbnode( keyblock );
782         keyblock = NULL;
783     }
784     if( rc == -1 )
785         rc = G10ERR_NO_PUBKEY;
786     else if( rc )
787         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
788
789   leave:
790     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
791     release_kbnode( keyblock );
792     set_packet_list_mode(oldmode);
793     return rc;
794 }
795
796 /****************
797  * Ditto for secret keys
798  */
799 static int
800 lookup_skc( PKT_secret_cert *skc, int mode,  u32 *keyid, const char *name )
801 {
802     int rc;
803     KBNODE keyblock = NULL;
804     KBPOS kbpos;
805     int oldmode = set_packet_list_mode(0);
806
807     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
808     if( rc ) {
809         if( rc == -1 )
810             rc = G10ERR_NO_SECKEY;
811         else if( rc )
812             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
813         goto leave;
814     }
815
816     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
817         KBNODE k, kk;
818         if( mode < 10 ) { /* name lookup */
819             for(k=keyblock; k; k = k->next ) {
820                 if( k->pkt->pkttype == PKT_USER_ID
821                     && !compare_name( k->pkt->pkt.user_id->name,
822                                       k->pkt->pkt.user_id->len, name, mode)) {
823                     /* we found a matching name, look for the key */
824                     for(kk=keyblock; kk; kk = kk->next )
825                         if( (    kk->pkt->pkttype == PKT_SECRET_CERT
826                               || kk->pkt->pkttype == PKT_SECKEY_SUBCERT )
827                             && ( !skc->pubkey_algo
828                                  || skc->pubkey_algo
829                                     == kk->pkt->pkt.secret_cert->pubkey_algo))
830                         break;
831                     if( kk ) {
832                         u32 aki[2];
833                         keyid_from_skc( kk->pkt->pkt.secret_cert, aki );
834                         cache_user_id( k->pkt->pkt.user_id, aki );
835                         k = kk;
836                         break;
837                     }
838                     else
839                         log_error("No key for userid (in skc)\n");
840                 }
841             }
842         }
843         else { /* keyid or fingerprint lookup */
844             if( DBG_CACHE && (mode== 10 || mode==11) ) {
845                 log_debug("lookup_skc keyid=%08lx%08lx req_algo=%d mode=%d\n",
846                                 (ulong)keyid[0], (ulong)keyid[1],
847                                  skc->pubkey_algo, mode );
848             }
849             for(k=keyblock; k; k = k->next ) {
850                 if(    k->pkt->pkttype == PKT_SECRET_CERT
851                     || k->pkt->pkttype == PKT_SECKEY_SUBCERT ) {
852                     if( mode == 10 || mode == 11 ) {
853                         u32 aki[2];
854                         keyid_from_skc( k->pkt->pkt.secret_cert, aki );
855                         if( DBG_CACHE ) {
856                             log_debug("             aki=%08lx%08lx algo=%d\n",
857                                             (ulong)aki[0], (ulong)aki[1],
858                                     k->pkt->pkt.secret_cert->pubkey_algo    );
859                         }
860                         if( aki[1] == keyid[1]
861                             && ( mode == 10 || aki[0] == keyid[0] )
862                             && ( !skc->pubkey_algo
863                                  || skc->pubkey_algo
864                                     == k->pkt->pkt.secret_cert->pubkey_algo) ){
865                             /* cache the userid */
866                             for(kk=keyblock; kk; kk = kk->next )
867                                 if( kk->pkt->pkttype == PKT_USER_ID )
868                                     break;
869                             if( kk )
870                                 cache_user_id( kk->pkt->pkt.user_id, aki );
871                             else
872                                 log_error("No userid for key\n");
873                             break; /* found */
874                         }
875                     }
876                     else if( mode == 15 ) { /* get the first key */
877                         if( !skc->pubkey_algo
878                             || skc->pubkey_algo
879                                   == k->pkt->pkt.secret_cert->pubkey_algo )
880                             break;
881                     }
882                     else if( mode == 16 || mode == 20 ) {
883                         size_t an;
884                         byte *afp = fingerprint_from_skc(
885                                         k->pkt->pkt.secret_cert, &an );
886                         if( an == mode && !memcmp( afp, name, an)
887                             && ( !skc->pubkey_algo
888                                  || skc->pubkey_algo
889                                     == k->pkt->pkt.secret_cert->pubkey_algo) ) {
890                             m_free(afp);
891                             break;
892                         }
893                         m_free(afp);
894                     }
895                     else
896                         BUG();
897                 } /* end compare secret keys */
898             }
899         }
900         if( k ) { /* found */
901             assert(    k->pkt->pkttype == PKT_SECRET_CERT
902                     || k->pkt->pkttype == PKT_SECKEY_SUBCERT );
903             copy_secret_cert( skc, k->pkt->pkt.secret_cert );
904             break; /* enumeration */
905         }
906         release_kbnode( keyblock );
907         keyblock = NULL;
908     }
909     if( rc == -1 )
910         rc = G10ERR_NO_SECKEY;
911     else if( rc )
912         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
913
914   leave:
915     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
916     release_kbnode( keyblock );
917     set_packet_list_mode(oldmode);
918     return rc;
919 }
920
921
922
923 /****************
924  * Enumerate all secret keys.  Caller must use these procedure:
925  *  1) create a void pointer and initialize it to NULL
926  *  2) pass this void pointer by reference to this function
927  *     and provide space for the secret key (pass a buffer for skc)
928  *  3) call this function as long as it does not return -1
929  *     to indicate EOF.
930  *  4) Always call this function a last time with SKC set to NULL,
931  *     so that can free it's context.
932  *
933  * Return
934  */
935 int
936 enum_secret_keys( void **context, PKT_secret_cert *skc )
937 {
938     int rc=0;
939     PACKET pkt;
940     int save_mode;
941     enum_seckey_context_t *c = *context;
942
943     if( !c ) { /* make a new context */
944         c = m_alloc_clear( sizeof *c );
945         *context = c;
946         c->sl = secret_keyrings;
947     }
948
949     if( !skc ) { /* free the context */
950         m_free( c );
951         *context = NULL;
952         return 0;
953     }
954
955     if( c->eof )
956         return -1;
957
958     for( ; c->sl; c->sl = c->sl->next ) {
959         if( !c->iobuf ) {
960             if( !(c->iobuf = iobuf_open( c->sl->d ) ) ) {
961                 log_error("enum_secret_keys: can't open '%s'\n", c->sl->d );
962                 continue; /* try next file */
963             }
964         }
965
966         save_mode = set_packet_list_mode(0);
967         init_packet(&pkt);
968         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
969             if( rc )
970                 ; /* e.g. unknown packet */
971             else if( pkt.pkttype == PKT_SECRET_CERT
972                     || pkt.pkttype == PKT_SECKEY_SUBCERT ) {
973                 copy_secret_cert( skc, pkt.pkt.secret_cert );
974                 set_packet_list_mode(save_mode);
975                 return 0; /* found */
976             }
977             free_packet(&pkt);
978         }
979         set_packet_list_mode(save_mode);
980         iobuf_close(c->iobuf); c->iobuf = NULL;
981     }
982     c->eof = 1;
983     return -1;
984 }
985
986
987 /****************
988  * Return a string with a printable representation of the user_id.
989  * this string must be freed by m_free.
990  */
991 char*
992 get_user_id_string( u32 *keyid )
993 {
994     user_id_db_t r;
995     char *p;
996     int pass=0;
997     /* try it two times; second pass reads from keyrings */
998     do {
999         for(r=user_id_db; r; r = r->next )
1000             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1001                 p = m_alloc( r->len + 10 );
1002                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1003                 return p;
1004             }
1005     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1006     p = m_alloc( 15 );
1007     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1008     return p;
1009 }
1010
1011 char*
1012 get_user_id( u32 *keyid, size_t *rn )
1013 {
1014     user_id_db_t r;
1015     char *p;
1016     int pass=0;
1017     /* try it two times; second pass reads from keyrings */
1018     do {
1019         for(r=user_id_db; r; r = r->next )
1020             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1021                 p = m_alloc( r->len );
1022                 memcpy(p, r->name, r->len );
1023                 *rn = r->len;
1024                 return p;
1025             }
1026     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1027     p = m_alloc( 19 );
1028     memcpy(p, "[User id not found]", 19 );
1029     *rn = 19;
1030     return p;
1031 }
1032
1033