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