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