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