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