See ChangeLog: Thu Jan 7 18:00:58 CET 1999 Werner Koch
[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 #define DEFINES_GETKEY_CTX 1
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <assert.h>
28 #include <ctype.h>
29 #include "util.h"
30 #include "packet.h"
31 #include "memory.h"
32 #include "iobuf.h"
33 #include "keydb.h"
34 #include "options.h"
35 #include "main.h"
36 #include "i18n.h"
37
38 #define MAX_UNK_CACHE_ENTRIES 1000   /* we use a linked list - so I guess
39                                       * this is a reasonable limit */
40 #define MAX_PK_CACHE_ENTRIES    50
41 #define MAX_UID_CACHE_ENTRIES   50
42
43
44 struct getkey_ctx_s {
45     int mode;
46     int internal;
47     u32 keyid[2];
48     char *namebuf;
49     const char *name;
50     int primary;
51     KBNODE keyblock;
52     KBPOS kbpos;
53     int last_rc;
54     ulong count;
55 };
56
57
58
59
60
61
62 static struct {
63     int any;
64     int okay_count;
65     int nokey_count;
66     int error_count;
67 } lkup_stats[21];
68
69
70
71
72 #if MAX_UNK_CACHE_ENTRIES
73   typedef struct keyid_list {
74       struct keyid_list *next;
75       u32 keyid[2];
76   } *keyid_list_t;
77   static keyid_list_t unknown_keyids;
78   static int unk_cache_entries;   /* number of entries in unknown keys cache */
79   static int unk_cache_disabled;
80 #endif
81
82 #if MAX_PK_CACHE_ENTRIES
83   typedef struct pk_cache_entry {
84       struct pk_cache_entry *next;
85       u32 keyid[2];
86       PKT_public_key *pk;
87   } *pk_cache_entry_t;
88   static pk_cache_entry_t pk_cache;
89   static int pk_cache_entries;   /* number of entries in pk cache */
90   static int pk_cache_disabled;
91 #endif
92
93 #if MAX_UID_CACHE_ENTRIES < 5
94     #error we really need the userid cache
95 #endif
96 typedef struct user_id_db {
97     struct user_id_db *next;
98     u32 keyid[2];
99     int len;
100     char name[1];
101 } *user_id_db_t;
102 static user_id_db_t user_id_db;
103 static int uid_cache_entries;   /* number of entries in uid cache */
104
105
106
107 static int lookup( GETKEY_CTX *ctx, PKT_public_key *pk,
108                    int mode,  u32 *keyid, const char *name,
109                    KBNODE *ret_keyblock, int primary  );
110 static void lookup_close( GETKEY_CTX ctx );
111 static int  lookup_read( GETKEY_CTX ctx,
112                          PKT_public_key *pk, KBNODE *ret_keyblock );
113 static int lookup_sk( PKT_secret_key *sk,
114                    int mode,  u32 *keyid, const char *name, int primary );
115
116
117
118 static void
119 print_stats()
120 {
121     int i;
122     for(i=0; i < DIM(lkup_stats); i++ ) {
123         if( lkup_stats[i].any )
124             fprintf(stderr,
125                     "lookup stats: mode=%-2d  ok=%-6d  nokey=%-6d  err=%-6d\n",
126                     i,
127                     lkup_stats[i].okay_count,
128                     lkup_stats[i].nokey_count,
129                     lkup_stats[i].error_count );
130     }
131 }
132
133
134
135 static void
136 cache_public_key( PKT_public_key *pk )
137 {
138   #if MAX_PK_CACHE_ENTRIES
139     pk_cache_entry_t ce;
140     u32 keyid[2];
141
142     if( pk_cache_disabled )
143         return;
144
145     if( is_ELGAMAL(pk->pubkey_algo)
146         || pk->pubkey_algo == PUBKEY_ALGO_DSA
147         || is_RSA(pk->pubkey_algo) ) {
148         keyid_from_pk( pk, keyid );
149     }
150     else
151         return; /* don't know how to get the keyid */
152
153     for( ce = pk_cache; ce; ce = ce->next )
154         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
155             if( DBG_CACHE )
156                 log_debug("cache_public_key: already in cache\n");
157             return;
158         }
159
160     if( pk_cache_entries >= MAX_PK_CACHE_ENTRIES ) {
161         /* fixme: use another algorithm to free some cache slots */
162         pk_cache_disabled=1;
163         if( opt.verbose > 1 )
164             log_info(_("too many entries in pk cache - disabled\n"));
165         return;
166     }
167     pk_cache_entries++;
168     ce = m_alloc( sizeof *ce );
169     ce->next = pk_cache;
170     pk_cache = ce;
171     ce->pk = copy_public_key( NULL, pk );
172     ce->keyid[0] = keyid[0];
173     ce->keyid[1] = keyid[1];
174   #endif
175 }
176
177
178 /****************
179  * Store the association of keyid and userid
180  */
181 void
182 cache_user_id( PKT_user_id *uid, u32 *keyid )
183 {
184     user_id_db_t r;
185
186     for(r=user_id_db; r; r = r->next )
187         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
188             if( DBG_CACHE )
189                log_debug("cache_user_id: already in cache\n");
190             return;
191         }
192
193     if( uid_cache_entries >= MAX_UID_CACHE_ENTRIES ) {
194         /* fixme: use another algorithm to free some cache slots */
195         r = user_id_db;
196         user_id_db = r->next;
197         m_free(r);
198         uid_cache_entries--;
199     }
200     r = m_alloc( sizeof *r + uid->len-1 );
201     r->keyid[0] = keyid[0];
202     r->keyid[1] = keyid[1];
203     r->len = uid->len;
204     memcpy(r->name, uid->name, r->len);
205     r->next = user_id_db;
206     user_id_db = r;
207     uid_cache_entries++;
208 }
209
210
211 void
212 getkey_disable_caches()
213 {
214   #if MAX_UNK_CACHE_ENTRIES
215     {
216         keyid_list_t kl, kl2;
217         for( kl = unknown_keyids; kl; kl = kl2 ) {
218             kl2 = kl->next;
219             m_free(kl);
220         }
221         unknown_keyids = NULL;
222         unk_cache_disabled = 1;
223     }
224   #endif
225   #if MAX_PK_CACHE_ENTRIES
226     {
227         pk_cache_entry_t ce, ce2;
228         u32 keyid[2];
229
230         for( ce = pk_cache; ce; ce = ce2 ) {
231             ce2 = ce->next;
232             free_public_key( ce->pk );
233             m_free( ce );
234         }
235         pk_cache_disabled=1;
236         pk_cache_entries = 0;
237         pk_cache = NULL;
238     }
239   #endif
240     /* fixme: disable user id cache ? */
241 }
242
243
244 /****************
245  * Get a public key and store it into the allocated pk
246  * can be called with PK set to NULL to just read it into some
247  * internal structures.
248  */
249 int
250 get_pubkey( PKT_public_key *pk, u32 *keyid )
251 {
252     int internal = 0;
253     int rc = 0;
254
255   #if MAX_UNK_CACHE_ENTRIES
256     {   /* let's see whether we checked the keyid already */
257         keyid_list_t kl;
258         for( kl = unknown_keyids; kl; kl = kl->next )
259             if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
260                 return G10ERR_NO_PUBKEY; /* already checked and not found */
261     }
262   #endif
263
264   #if MAX_PK_CACHE_ENTRIES
265     {   /* Try to get it from the cache */
266         pk_cache_entry_t ce;
267         for( ce = pk_cache; ce; ce = ce->next ) {
268             if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
269                 if( pk )
270                     copy_public_key( pk, ce->pk );
271                 return 0;
272             }
273         }
274     }
275   #endif
276     /* more init stuff */
277     if( !pk ) {
278         pk = m_alloc_clear( sizeof *pk );
279         internal++;
280     }
281
282
283     /* do a lookup */
284     rc = lookup( NULL, pk, 11, keyid, NULL, NULL, 0 );
285     if( !rc )
286         goto leave;
287
288   #if MAX_UNK_CACHE_ENTRIES
289     /* not found: store it for future reference */
290     if( unk_cache_disabled )
291         ;
292     else if( ++unk_cache_entries > MAX_UNK_CACHE_ENTRIES ) {
293         unk_cache_disabled = 1;
294         if( opt.verbose > 1 )
295             log_info(_("too many entries in unk cache - disabled\n"));
296     }
297     else {
298         keyid_list_t kl;
299
300         kl = m_alloc( sizeof *kl );
301         kl->keyid[0] = keyid[0];
302         kl->keyid[1] = keyid[1];
303         kl->next = unknown_keyids;
304         unknown_keyids = kl;
305     }
306   #endif
307     rc = G10ERR_NO_PUBKEY;
308
309   leave:
310     if( !rc )
311         cache_public_key( pk );
312     if( internal )
313         free_public_key(pk);
314     return rc;
315 }
316
317
318 static int
319 hextobyte( const byte *s )
320 {
321     int c;
322
323     if( *s >= '0' && *s <= '9' )
324         c = 16 * (*s - '0');
325     else if( *s >= 'A' && *s <= 'F' )
326         c = 16 * (10 + *s - 'A');
327     else if( *s >= 'a' && *s <= 'f' )
328         c = 16 * (10 + *s - 'a');
329     else
330         return -1;
331     s++;
332     if( *s >= '0' && *s <= '9' )
333         c += *s - '0';
334     else if( *s >= 'A' && *s <= 'F' )
335         c += 10 + *s - 'A';
336     else if( *s >= 'a' && *s <= 'f' )
337         c += 10 + *s - 'a';
338     else
339         return -1;
340     return c;
341 }
342
343
344
345 /****************
346  * Return the type of the user id:
347  *
348  *  0 = Invalid user ID
349  *  1 = exact match
350  *  2 = match a substring
351  *  3 = match an email address
352  *  4 = match a substring of an email address
353  *  5 = match an email address, but compare from end
354  * 10 = it is a short KEYID (don't care about keyid[0])
355  * 11 = it is a long  KEYID
356  * 16 = it is a 16 byte fingerprint
357  * 20 = it is a 20 byte fingerprint
358  *
359  * if fprint is not NULL, it should be an array of at least 20 bytes.
360  *
361  * Rules used:
362  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
363  *   must be in the range 0..9), this is considered a keyid; depending
364  *   on the length a short or complete one.
365  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
366  *   must be in the range 0..9), this is considered a fingerprint.
367  * - If the username starts with a left angle, we assume it is a complete
368  *   email address and look only at this part.
369  * - If the username starts with a '.', we assume it is the ending
370  *   part of an email address
371  * - If the username starts with an '@', we assume it is a part of an
372  *   email address
373  * - If the userid start with an '=' an exact compare is done.
374  * - If the userid starts with a '*' a case insensitive substring search is
375  *   done (This is the default).
376  */
377
378 int
379 classify_user_id( const char *name, u32 *keyid, byte *fprint,
380                   const char **retstr, size_t *retlen )
381 {
382     const char *s;
383     int mode = 0;
384
385     /* check what kind of name it is */
386     for(s = name; *s && isspace(*s); s++ )
387         ;
388     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
389         int i, j;
390         char buf[9];
391
392         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
393             s += 2; /*kludge to allow 0x034343434 */
394         for(i=0; isxdigit(s[i]); i++ )
395             ;
396         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
397             return 0;
398         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
399             if( i==9 )
400                 s++;
401             if( keyid ) {
402                 keyid[0] = 0;
403                 keyid[1] = strtoul( s, NULL, 16 );
404             }
405             mode = 10;
406         }
407         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
408             if( i==17 )
409                 s++;
410             mem2str(buf, s, 9 );
411             keyid[0] = strtoul( buf, NULL, 16 );
412             keyid[1] = strtoul( s+8, NULL, 16 );
413             mode = 11;
414         }
415         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
416             if( i==33 )
417                 s++;
418             if( fprint ) {
419                 memset(fprint+16, 4, 0);
420                 for(j=0; j < 16; j++, s+=2 ) {
421                     int c = hextobyte( s );
422                     if( c == -1 )
423                         return 0;
424                     fprint[j] = c;
425                 }
426             }
427             mode = 16;
428         }
429         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
430             if( i==33 )
431                 s++;
432             if( fprint ) {
433                 for(j=0; j < 20; j++, s+=2 ) {
434                     int c = hextobyte( s );
435                     if( c == -1 )
436                         return 0;
437                     fprint[j] = c;
438                 }
439             }
440             mode = 20;
441         }
442         else
443             return 0;
444     }
445     else if( *s == '=' ) { /* exact search */
446         mode = 1;
447         s++;
448     }
449     else if( *s == '*' ) { /* substring search */
450         mode = 2;
451         s++;
452     }
453     else if( *s == '<' ) { /* an email address */
454         mode = 3;
455     }
456     else if( *s == '@' ) { /* a part of an email address */
457         mode = 4;
458         s++;
459     }
460     else if( *s == '.' ) { /* an email address, compare from end */
461         mode = 5;
462         s++;
463     }
464     else if( *s == '#' ) { /* use local id */
465         return 0;
466     }
467     else if( !*s )  /* empty string */
468         return 0;
469     else
470         mode = 2;
471
472     if( retstr )
473         *retstr = s;
474     if( retlen )
475         *retlen = strlen(s);
476
477     return mode;
478 }
479
480
481
482 /****************
483  * Try to get the pubkey by the userid. This function looks for the
484  * first pubkey certificate which has the given name in a user_id.
485  * if pk has the pubkey algo set, the function will only return
486  * a pubkey with that algo.
487  */
488
489 static int
490 key_byname( int secret, GETKEY_CTX *retctx,
491             PKT_public_key *pk, PKT_secret_key *sk,
492             const char *name, KBNODE *ret_kb )
493 {
494     int internal = 0;
495     int rc = 0;
496     const char *s;
497     u32 keyid[2] = {0}; /* init to avoid compiler warning */
498     byte fprint[20];
499     int mode;
500
501     mode = classify_user_id( name, keyid, fprint, &s, NULL );
502     if( !mode ) {
503         rc = G10ERR_INV_USER_ID;
504         goto leave;
505     }
506
507     if( secret ) {
508         if( !sk ) {
509             sk = m_alloc_clear( sizeof *sk );
510             internal++;
511         }
512         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
513                       : lookup_sk( sk, mode, keyid, fprint, 1 );
514     }
515     else {
516         if( !pk ) {
517             pk = m_alloc_clear( sizeof *pk );
518             internal++;
519         }
520         rc = mode < 16? lookup( retctx, pk, mode, keyid, s, ret_kb, 1 )
521                       : lookup( retctx, pk, mode, keyid, fprint, ret_kb, 1 );
522     }
523
524
525   leave:
526     if( internal && secret )
527         m_free( sk );
528     else if( internal )
529         m_free( pk );
530     return rc;
531 }
532
533 int
534 get_pubkey_byname( GETKEY_CTX *retctx, PKT_public_key *pk,
535                    const char *name, KBNODE *ret_keyblock )
536 {
537     int rc;
538
539     if( !pk ) {
540         /* fixme: key_byname should not need a pk in this case */
541         pk = m_alloc_clear( sizeof *pk );
542         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
543         free_public_key( pk );
544     }
545     else
546         rc = key_byname( 0, retctx, pk, NULL, name, ret_keyblock );
547     return rc;
548 }
549
550 int
551 get_pubkey_next( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
552 {
553     int rc;
554
555     if( !pk ) {
556         /* fixme: lookup_read should not need a pk in this case */
557         pk = m_alloc_clear( sizeof *pk );
558         rc = lookup_read( ctx, pk, ret_keyblock );
559         free_public_key( pk );
560     }
561     else
562         rc = lookup_read( ctx, pk, ret_keyblock );
563     return rc;
564 }
565
566 void
567 get_pubkey_end( GETKEY_CTX ctx )
568 {
569     if( ctx ) {
570         lookup_close( ctx );
571         m_free( ctx );
572     }
573 }
574
575 /****************
576  * Search for a key with the given fingerprint.
577  */
578 int
579 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
580 {
581     int rc;
582
583     if( fprint_len == 20 || fprint_len == 16 )
584         rc = lookup( NULL, pk, fprint_len, NULL, fprint, NULL, 0 );
585     else
586         rc = G10ERR_GENERAL; /* Oops */
587     return rc;
588 }
589
590 /****************
591  * Search for a key with the given fingerprint and return the
592  * complete keyblock which may have more than only this key.
593  */
594 int
595 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
596                                                 size_t fprint_len )
597 {
598     int rc;
599     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
600
601     if( fprint_len == 20 || fprint_len == 16 )
602         rc = lookup( NULL, pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
603     else
604         rc = G10ERR_GENERAL; /* Oops */
605
606     free_public_key( pk );
607     return rc;
608 }
609
610 /****************
611  * Get a secret key and store it into sk
612  */
613 int
614 get_seckey( PKT_secret_key *sk, u32 *keyid )
615 {
616     int rc;
617
618     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
619     if( !rc ) {
620         /* check the secret key (this may prompt for a passprase to
621          * unlock the secret key
622          */
623         rc = check_secret_key( sk, 0 );
624     }
625
626     return rc;
627 }
628
629 /****************
630  * Get the primary secret key and store it into sk
631  * Note: This function does not unprotect the key!
632  */
633 int
634 get_primary_seckey( PKT_secret_key *sk, u32 *keyid )
635 {
636     return lookup_sk( sk, 11, keyid, NULL, 1 );
637 }
638
639 /****************
640  * Check whether the secret key is available
641  * Returns: 0 := key is available
642  *          G10ERR_NO_SECKEY := not availabe
643  */
644 int
645 seckey_available( u32 *keyid )
646 {
647     PKT_secret_key *sk;
648     int rc;
649
650     sk = m_alloc_clear( sizeof *sk );
651     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
652     free_secret_key( sk );
653     return rc;
654 }
655
656
657
658 /****************
659  * Get a secret key by name and store it into sk
660  * If NAME is NULL use the default key
661  */
662 int
663 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
664 {
665     int rc;
666
667     if( !name && opt.def_secret_key && *opt.def_secret_key )
668         rc = key_byname( 1, NULL, NULL, sk, opt.def_secret_key, NULL );
669     else if( !name ) /* use the first one as default key */
670         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
671     else
672         rc = key_byname( 1, NULL, NULL, sk, name, NULL );
673     if( !rc && unprotect )
674         rc = check_secret_key( sk, 0 );
675
676     return rc;
677 }
678
679
680 static int
681 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
682 {
683     int i;
684     const char *s, *se;
685
686     if( mode == 1 ) {  /* exact match */
687         for(i=0; name[i] && uidlen; i++, uidlen-- )
688             if( uid[i] != name[i] )
689                 break;
690         if( !uidlen && !name[i] )
691             return 0; /* found */
692     }
693     else if( mode == 2 ) { /* case insensitive substring */
694         if( memistr( uid, uidlen, name ) )
695             return 0;
696     }
697     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
698         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
699             ;
700         if( i < uidlen )  {
701             /* skip opening delim and one char and look for the closing one*/
702             s++; i++;
703             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
704                 ;
705             if( i < uidlen ) {
706                 i = se - s;
707                 if( mode == 3 ) { /* exact email address */
708                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
709                         return 0;
710                 }
711                 else if( mode == 4 ) {  /* email substring */
712                     if( memistr( s, i, name ) )
713                         return 0;
714                 }
715                 else { /* email from end */
716                     /* nyi */
717                 }
718             }
719         }
720     }
721     else
722         BUG();
723
724     return -1; /* not found */
725 }
726
727
728
729 /****************
730  * Assume that knode points to a public key packet  and keyblock is
731  * the entire keyblock.  This function adds all relevant information from
732  * a selfsignature to the public key.
733  */
734
735 static void
736 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode,
737                           PKT_public_key *orig_pk )
738 {
739     PKT_public_key *pk = knode->pkt->pkt.public_key;
740     PKT_signature *sig;
741     KBNODE k;
742     u32 kid[2];
743     u32 sigdate = 0;
744
745     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
746             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
747
748     if( pk->version < 4 )
749         return; /* this is only needed for version >=4 packets */
750
751
752     /* find the selfsignature */
753     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
754         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
755         if( !k )
756            BUG(); /* keyblock without primary key!!! */
757         keyid_from_pk( knode->pkt->pkt.public_key, kid );
758     }
759     else
760         keyid_from_pk( pk, kid );
761
762     for(k=knode->next; k; k = k->next ) {
763         if( k->pkt->pkttype == PKT_SIGNATURE
764             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
765             && sig->sig_class <= 0x30
766             && sig->keyid[0] == kid[0]
767             && sig->keyid[1] == kid[1]
768             && sig->version > 3 ) {
769             /* okay this is a self-signature which can be used.
770              * We use the latest self-signature.
771              * FIXME: We should only use this if the signature is valid
772              *        but this is time consuming - we must provide another
773              *        way to handle this
774              */
775             const byte *p;
776             u32 ed;
777
778             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
779             ed = p? pk->timestamp + buffer_to_u32(p):0;
780             /* use the latest self signature */
781             if( sig->timestamp > sigdate ) {
782                 pk->expiredate = ed;
783                 orig_pk->expiredate = ed;
784                 sigdate = sig->timestamp;
785             }
786             /* fixme: add usage etc. to pk */
787         }
788         else if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
789             break; /* stop here */
790     }
791 }
792
793
794 /****************
795  * merge all selfsignatures with the keys.
796  */
797 void
798 merge_keys_and_selfsig( KBNODE keyblock )
799 {
800     PKT_public_key *pk = NULL;
801     PKT_secret_key *sk = NULL;
802     PKT_signature *sig;
803     KBNODE k;
804     u32 kid[2] = { 0, 0 };
805     u32 sigdate = 0;
806
807     for(k=keyblock; k; k = k->next ) {
808         if( k->pkt->pkttype == PKT_PUBLIC_KEY
809             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
810             pk = k->pkt->pkt.public_key; sk = NULL;
811             if( pk->version < 4 )
812                 pk = NULL; /* not needed for old keys */
813             else if( k->pkt->pkttype == PKT_PUBLIC_KEY )
814                 keyid_from_pk( pk, kid );
815             sigdate = 0;
816         }
817         else if( k->pkt->pkttype == PKT_SECRET_KEY
818             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
819             pk = NULL; sk = k->pkt->pkt.secret_key;
820             if( sk->version < 4 )
821                 sk = NULL;
822             else if( k->pkt->pkttype == PKT_SECRET_KEY )
823                 keyid_from_sk( sk, kid );
824             sigdate = 0;
825         }
826         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
827                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
828                  && sig->sig_class <= 0x30 && sig->version > 3
829                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
830             /* okay this is a self-signature which can be used.
831              * FIXME: We should only use this if the signature is valid
832              *        but this is time consuming - we must provide another
833              *        way to handle this
834              */
835             const byte *p;
836             u32 ed;
837
838             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
839             if( pk ) {
840                 ed = p? pk->timestamp + buffer_to_u32(p):0;
841                 if( sig->timestamp > sigdate ) {
842                     pk->expiredate = ed;
843                     sigdate = sig->timestamp;
844                 }
845             }
846             else {
847                 ed = p? sk->timestamp + buffer_to_u32(p):0;
848                 if( sig->timestamp > sigdate ) {
849                     sk->expiredate = ed;
850                     sigdate = sig->timestamp;
851                 }
852             }
853         }
854     }
855 }
856
857
858 static KBNODE
859 find_by_name( KBNODE keyblock, PKT_public_key *pk, const char *name,
860               int mode, byte *namehash, int *use_namehash )
861 {
862     KBNODE k, kk;
863
864     for(k=keyblock; k; k = k->next ) {
865         if( k->pkt->pkttype == PKT_USER_ID
866             && !compare_name( k->pkt->pkt.user_id->name,
867                               k->pkt->pkt.user_id->len, name, mode)) {
868             /* we found a matching name, look for the key */
869             for(kk=keyblock; kk; kk = kk->next ) {
870                 if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
871                       || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
872                     && ( !pk->pubkey_algo
873                          || pk->pubkey_algo
874                             == kk->pkt->pkt.public_key->pubkey_algo)
875                     && ( !pk->pubkey_usage
876                          || !check_pubkey_algo2(
877                                kk->pkt->pkt.public_key->pubkey_algo,
878                                                    pk->pubkey_usage ))
879                   )
880                     break;
881             }
882             if( kk ) {
883                 u32 aki[2];
884                 keyid_from_pk( kk->pkt->pkt.public_key, aki );
885                 cache_user_id( k->pkt->pkt.user_id, aki );
886                 rmd160_hash_buffer( namehash,
887                                     k->pkt->pkt.user_id->name,
888                                     k->pkt->pkt.user_id->len );
889                 *use_namehash = 1;
890                 return kk;
891             }
892             else if( is_RSA(pk->pubkey_algo) )
893                 log_error("RSA key cannot be used in this version\n");
894             else
895                 log_error("No key for userid\n");
896         }
897     }
898     return NULL;
899 }
900
901
902 static KBNODE
903 find_by_keyid( KBNODE keyblock, PKT_public_key *pk, u32 *keyid, int mode )
904 {
905     KBNODE k;
906
907     if( DBG_CACHE )
908         log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
909                    (ulong)keyid[0], (ulong)keyid[1], pk->pubkey_algo, mode );
910
911     for(k=keyblock; k; k = k->next ) {
912         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
913             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
914             u32 aki[2];
915             keyid_from_pk( k->pkt->pkt.public_key, aki );
916             if( DBG_CACHE )
917                 log_debug("         aki=%08lx%08lx algo=%d\n",
918                                 (ulong)aki[0], (ulong)aki[1],
919                                  k->pkt->pkt.public_key->pubkey_algo    );
920
921             if( aki[1] == keyid[1]
922                 && ( mode == 10 || aki[0] == keyid[0] )
923                 && ( !pk->pubkey_algo
924                      || pk->pubkey_algo
925                         == k->pkt->pkt.public_key->pubkey_algo) ){
926                 KBNODE kk;
927                 /* cache the userid */
928                 for(kk=keyblock; kk; kk = kk->next )
929                     if( kk->pkt->pkttype == PKT_USER_ID )
930                         break;
931                 if( kk )
932                     cache_user_id( kk->pkt->pkt.user_id, aki );
933                 else
934                     log_error("No userid for key\n");
935                 return k; /* found */
936             }
937         }
938     }
939     return NULL;
940 }
941
942
943 static KBNODE
944 find_first( KBNODE keyblock, PKT_public_key *pk )
945 {
946     KBNODE k;
947
948     for(k=keyblock; k; k = k->next ) {
949         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
950             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY )
951         {
952             if( !pk->pubkey_algo
953                 || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo )
954                 return k;
955         }
956     }
957     return NULL;
958 }
959
960
961 static KBNODE
962 find_by_fpr( KBNODE keyblock, PKT_public_key *pk, const char *name, int mode )
963 {
964     KBNODE k;
965
966     for(k=keyblock; k; k = k->next ) {
967         if(    k->pkt->pkttype == PKT_PUBLIC_KEY
968             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
969             byte afp[MAX_FINGERPRINT_LEN];
970             size_t an;
971
972             fingerprint_from_pk(k->pkt->pkt.public_key, afp, &an );
973
974             if( DBG_CACHE ) {
975                 u32 aki[2];
976                 keyid_from_pk( k->pkt->pkt.public_key, aki );
977                 log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
978                                 (ulong)aki[0], (ulong)aki[1],
979                         k->pkt->pkt.public_key->pubkey_algo, mode, an );
980             }
981
982             if( an == mode
983                 && !memcmp( afp, name, an)
984                 && ( !pk->pubkey_algo
985                      || pk->pubkey_algo == k->pkt->pkt.public_key->pubkey_algo) )
986                 return k;
987         }
988     }
989     return NULL;
990 }
991
992
993 static void
994 finish_lookup( KBNODE keyblock, PKT_public_key *pk, KBNODE k, byte *namehash,
995                                                int use_namehash, int primary )
996 {
997     assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
998             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
999     assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
1000     if( primary && !pk->pubkey_usage ) {
1001         copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
1002                                       use_namehash? namehash:NULL);
1003         merge_one_pk_and_selfsig( keyblock, keyblock, pk );
1004     }
1005     else {
1006         if( primary && pk->pubkey_usage
1007             && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
1008                        pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
1009             /* if the usage is not correct, try to use a subkey */
1010             KBNODE save_k = k;
1011
1012             k = NULL;
1013             /* kludge for pgp 5: which doesn't accept type 20:
1014              * try to use a type 16 subkey instead */
1015             if( pk->pubkey_usage == PUBKEY_USAGE_ENC ) {
1016                 for( k = save_k; k; k = k->next ) {
1017                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1018                         && k->pkt->pkt.public_key->pubkey_algo
1019                             == PUBKEY_ALGO_ELGAMAL_E
1020                         && !check_pubkey_algo2(
1021                                 k->pkt->pkt.public_key->pubkey_algo,
1022                                                  pk->pubkey_usage ) )
1023                         break;
1024                 }
1025             }
1026
1027             if( !k ) {
1028                 for(k = save_k ; k; k = k->next ) {
1029                     if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
1030                         && !check_pubkey_algo2(
1031                                 k->pkt->pkt.public_key->pubkey_algo,
1032                                                  pk->pubkey_usage ) )
1033                         break;
1034                 }
1035             }
1036             if( !k )
1037                 k = save_k;
1038             else
1039                 log_info(_("using secondary key %08lX "
1040                            "instead of primary key %08lX\n"),
1041                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
1042                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
1043                         );
1044         }
1045
1046         copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
1047                                       use_namehash? namehash:NULL);
1048         merge_one_pk_and_selfsig( keyblock, k, pk );
1049     }
1050 }
1051
1052 /****************
1053  * Lookup a key by scanning all keyresources
1054  *   mode 1 = lookup by NAME (exact)
1055  *        2 = lookup by NAME (substring)
1056  *        3 = lookup by NAME (email address)
1057  *        4 = email address (substring)
1058  *        5 = email address (compare from end)
1059  *       10 = lookup by short KEYID (don't care about keyid[0])
1060  *       11 = lookup by long  KEYID
1061  *       15 = Get the first key.
1062  *       16 = lookup by 16 byte fingerprint which is stored in NAME
1063  *       20 = lookup by 20 byte fingerprint which is stored in NAME
1064  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
1065  * a key of this algo will be returned.
1066  * If ret_keyblock is not NULL, the complete keyblock is returned also
1067  * and the caller must release it.
1068  */
1069 static int
1070 lookup( GETKEY_CTX *retctx, PKT_public_key *pk, int mode, u32 *keyid,
1071         const char *name, KBNODE *ret_keyblock, int primary )
1072 {
1073     struct getkey_ctx_s help_ctx;
1074     GETKEY_CTX ctx;
1075     int rc;
1076
1077     if( !retctx )
1078         ctx = &help_ctx;
1079     else {
1080         ctx = m_alloc( sizeof *ctx );
1081         *retctx = ctx;
1082     }
1083
1084     memset( ctx, 0, sizeof *ctx );
1085     ctx->mode = mode;
1086     if( keyid ) {
1087         ctx->keyid[0] = keyid[0];
1088         ctx->keyid[1] = keyid[1];
1089     }
1090     if( retctx ) {
1091         ctx->namebuf = name? m_strdup(name) : NULL;
1092         ctx->name = ctx->namebuf;
1093     }
1094     else
1095         ctx->name = name;
1096     ctx->primary = primary;
1097     rc = lookup_read( ctx, pk, ret_keyblock );
1098     if( !retctx )
1099         lookup_close( ctx );
1100     return rc;
1101 }
1102
1103 static void
1104 lookup_close( GETKEY_CTX ctx )
1105 {
1106     enum_keyblocks( 2, &ctx->kbpos, NULL ); /* close */
1107     m_free( ctx->namebuf );
1108 }
1109
1110 static int
1111 lookup_read( GETKEY_CTX ctx, PKT_public_key *pk, KBNODE *ret_keyblock )
1112 {
1113     int rc;
1114     KBNODE k;
1115     int oldmode = set_packet_list_mode(0);
1116     byte namehash[20];
1117     int use_namehash=0;
1118
1119     /* try the quick functions */
1120     if( !ctx->count ) {
1121         k = NULL;
1122         switch( ctx->mode ) {
1123           case 10:
1124           case 11:
1125             rc = locate_keyblock_by_keyid( &ctx->kbpos, ctx->keyid,
1126                                                         ctx->mode==10, 0 );
1127             if( !rc )
1128                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1129             if( !rc )
1130                 k = find_by_keyid( ctx->keyblock, pk, ctx->keyid, ctx->mode );
1131             break;
1132
1133           case 16:
1134           case 20:
1135             rc = locate_keyblock_by_fpr( &ctx->kbpos, ctx->name, ctx->mode, 0 );
1136             if( !rc )
1137                 rc = read_keyblock( &ctx->kbpos, &ctx->keyblock );
1138             if( !rc )
1139                 k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1140             break;
1141
1142           default: rc = G10ERR_UNSUPPORTED;
1143         }
1144         if( !rc ) {
1145             if( !k ) {
1146                 log_error("lookup: key has been located but was not found\n");
1147                 rc = G10ERR_INV_KEYRING;
1148             }
1149             else
1150                 finish_lookup( ctx->keyblock, pk, k, namehash, 0, ctx->primary );
1151         }
1152     }
1153     else
1154         rc = G10ERR_UNSUPPORTED;
1155
1156     /* if this was not possible, loop over all keyblocks
1157      * fixme: If one of the resources in the quick functions above
1158      *        works, but the key was not found, we will not find it
1159      *        in the other resources */
1160     if( rc == G10ERR_UNSUPPORTED ) {
1161         if( !ctx->count )
1162             rc = enum_keyblocks( 0, &ctx->kbpos, &ctx->keyblock );
1163         else
1164             rc = 0;
1165         if( !rc ) {
1166             while( !(rc = enum_keyblocks( 1, &ctx->kbpos, &ctx->keyblock )) ) {
1167                 /* fixme: we donĀ“t enum the complete keyblock, but
1168                  * use the first match and that continue with the next keyblock
1169                  */
1170                 if( ctx->mode < 10 )
1171                     k = find_by_name( ctx->keyblock, pk, ctx->name, ctx->mode,
1172                                                     namehash, &use_namehash);
1173                 else if( ctx->mode == 10 ||ctx-> mode == 11 )
1174                     k = find_by_keyid( ctx->keyblock, pk, ctx->keyid,
1175                                                                 ctx->mode );
1176                 else if( ctx->mode == 15 )
1177                     k = find_first( ctx->keyblock, pk );
1178                 else if( ctx->mode == 16 || ctx->mode == 20 )
1179                     k = find_by_fpr( ctx->keyblock, pk, ctx->name, ctx->mode );
1180                 else
1181                     BUG();
1182                 if( k ) {
1183                     finish_lookup( ctx->keyblock, pk, k, namehash,
1184                                                  use_namehash, ctx->primary );
1185                     break; /* found */
1186                 }
1187                 release_kbnode( ctx->keyblock );
1188                 ctx->keyblock = NULL;
1189             }
1190         }
1191         if( rc && rc != -1 )
1192             log_error("enum_keyblocks failed: %s\n", g10_errstr(rc));
1193     }
1194
1195     if( !rc ) {
1196         if( ret_keyblock ) {
1197             *ret_keyblock = ctx->keyblock;
1198             ctx->keyblock = NULL;
1199         }
1200     }
1201     else if( rc == -1 )
1202         rc = G10ERR_NO_PUBKEY;
1203
1204     release_kbnode( ctx->keyblock );
1205     ctx->keyblock = NULL;
1206     set_packet_list_mode(oldmode);
1207     if( opt.debug & DBG_MEMSTAT_VALUE ) {
1208         static int initialized;
1209
1210         if( !initialized ) {
1211             initialized = 1;
1212             atexit( print_stats );
1213         }
1214
1215         assert( ctx->mode < DIM(lkup_stats) );
1216         lkup_stats[ctx->mode].any = 1;
1217         if( !rc )
1218             lkup_stats[ctx->mode].okay_count++;
1219         else if ( rc == G10ERR_NO_PUBKEY )
1220             lkup_stats[ctx->mode].nokey_count++;
1221         else
1222             lkup_stats[ctx->mode].error_count++;
1223     }
1224
1225     ctx->last_rc = rc;
1226     ctx->count++;
1227     return rc;
1228 }
1229
1230
1231 /****************
1232  * Ditto for secret keys
1233  */
1234 static int
1235 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
1236            int primary )
1237 {
1238     int rc;
1239     KBNODE keyblock = NULL;
1240     KBPOS kbpos;
1241     int oldmode = set_packet_list_mode(0);
1242
1243     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
1244     if( rc ) {
1245         if( rc == -1 )
1246             rc = G10ERR_NO_SECKEY;
1247         else if( rc )
1248             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
1249         goto leave;
1250     }
1251
1252     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
1253         KBNODE k, kk;
1254         if( mode < 10 ) { /* name lookup */
1255             for(k=keyblock; k; k = k->next ) {
1256                 if( k->pkt->pkttype == PKT_USER_ID
1257                     && !compare_name( k->pkt->pkt.user_id->name,
1258                                       k->pkt->pkt.user_id->len, name, mode)) {
1259                     /* we found a matching name, look for the key */
1260                     for(kk=keyblock; kk; kk = kk->next ) {
1261                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
1262                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
1263                             && ( !sk->pubkey_algo
1264                                  || sk->pubkey_algo
1265                                     == kk->pkt->pkt.secret_key->pubkey_algo)
1266                             && ( !sk->pubkey_usage
1267                                  || !check_pubkey_algo2(
1268                                        kk->pkt->pkt.secret_key->pubkey_algo,
1269                                                            sk->pubkey_usage ))
1270                           )
1271                             break;
1272                     }
1273                     if( kk ) {
1274                         u32 aki[2];
1275                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
1276                         cache_user_id( k->pkt->pkt.user_id, aki );
1277                         k = kk;
1278                         break;
1279                     }
1280                     else
1281                         log_error("No key for userid (in sk)\n");
1282                 }
1283             }
1284         }
1285         else { /* keyid or fingerprint lookup */
1286             if( DBG_CACHE && (mode== 10 || mode==11) ) {
1287                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
1288                                 (ulong)keyid[0], (ulong)keyid[1],
1289                                  sk->pubkey_algo, mode );
1290             }
1291             for(k=keyblock; k; k = k->next ) {
1292                 if(    k->pkt->pkttype == PKT_SECRET_KEY
1293                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
1294                     if( mode == 10 || mode == 11 ) {
1295                         u32 aki[2];
1296                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
1297                         if( DBG_CACHE ) {
1298                             log_debug("             aki=%08lx%08lx algo=%d\n",
1299                                             (ulong)aki[0], (ulong)aki[1],
1300                                     k->pkt->pkt.secret_key->pubkey_algo    );
1301                         }
1302                         if( aki[1] == keyid[1]
1303                             && ( mode == 10 || aki[0] == keyid[0] )
1304                             && ( !sk->pubkey_algo
1305                                  || sk->pubkey_algo
1306                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
1307                             /* cache the userid */
1308                             for(kk=keyblock; kk; kk = kk->next )
1309                                 if( kk->pkt->pkttype == PKT_USER_ID )
1310                                     break;
1311                             if( kk )
1312                                 cache_user_id( kk->pkt->pkt.user_id, aki );
1313                             else
1314                                 log_error("No userid for key\n");
1315                             break; /* found */
1316                         }
1317                     }
1318                     else if( mode == 15 ) { /* get the first key */
1319                         if( !sk->pubkey_algo
1320                             || sk->pubkey_algo
1321                                   == k->pkt->pkt.secret_key->pubkey_algo )
1322                             break;
1323                     }
1324                     else if( mode == 16 || mode == 20 ) {
1325                         size_t an;
1326                         byte afp[MAX_FINGERPRINT_LEN];
1327
1328                         fingerprint_from_sk(k->pkt->pkt.secret_key, afp, &an );
1329                         if( an == mode && !memcmp( afp, name, an)
1330                             && ( !sk->pubkey_algo
1331                                  || sk->pubkey_algo
1332                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1333                             break;
1334                         }
1335                     }
1336                     else
1337                         BUG();
1338                 } /* end compare secret keys */
1339             }
1340         }
1341         if( k ) { /* found */
1342             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1343                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1344             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1345             if( primary && !sk->pubkey_usage )
1346                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1347             else
1348                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1349             break; /* enumeration */
1350         }
1351         release_kbnode( keyblock );
1352         keyblock = NULL;
1353     }
1354     if( rc == -1 )
1355         rc = G10ERR_NO_SECKEY;
1356     else if( rc )
1357         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1358
1359   leave:
1360     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1361     release_kbnode( keyblock );
1362     set_packet_list_mode(oldmode);
1363     return rc;
1364 }
1365
1366
1367
1368 /****************
1369  * Enumerate all primary secret keys.  Caller must use these procedure:
1370  *  1) create a void pointer and initialize it to NULL
1371  *  2) pass this void pointer by reference to this function
1372  *     and provide space for the secret key (pass a buffer for sk)
1373  *  3) call this function as long as it does not return -1
1374  *     to indicate EOF.
1375  *  4) Always call this function a last time with SK set to NULL,
1376  *     so that can free it's context.
1377  *
1378  *
1379  */
1380 int
1381 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1382 {
1383     int rc=0;
1384     PACKET pkt;
1385     int save_mode;
1386     struct {
1387         int eof;
1388         int sequence;
1389         const char *name;
1390         IOBUF iobuf;
1391     } *c = *context;
1392
1393
1394     if( !c ) { /* make a new context */
1395         c = m_alloc_clear( sizeof *c );
1396         *context = c;
1397         c->sequence = 0;
1398         c->name = enum_keyblock_resources( &c->sequence, 1 );
1399     }
1400
1401     if( !sk ) { /* free the context */
1402         if( c->iobuf )
1403             iobuf_close(c->iobuf);
1404         m_free( c );
1405         *context = NULL;
1406         return 0;
1407     }
1408
1409     if( c->eof )
1410         return -1;
1411
1412     /* FIXME: This assumes a plain keyring file */
1413     for( ; c->name; c->name = enum_keyblock_resources( &c->sequence, 1 ) ) {
1414         if( !c->iobuf ) {
1415             if( !(c->iobuf = iobuf_open( c->name ) ) ) {
1416                 log_error("enum_secret_keys: can't open `%s'\n", c->name );
1417                 continue; /* try next file */
1418             }
1419         }
1420
1421         save_mode = set_packet_list_mode(0);
1422         init_packet(&pkt);
1423         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1424             if( rc )
1425                 ; /* e.g. unknown packet */
1426             else if( pkt.pkttype == PKT_SECRET_KEY
1427                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1428                 copy_secret_key( sk, pkt.pkt.secret_key );
1429                 set_packet_list_mode(save_mode);
1430                 return 0; /* found */
1431             }
1432             free_packet(&pkt);
1433         }
1434         set_packet_list_mode(save_mode);
1435         iobuf_close(c->iobuf); c->iobuf = NULL;
1436     }
1437     c->eof = 1;
1438     return -1;
1439 }
1440
1441
1442 /****************
1443  * Return a string with a printable representation of the user_id.
1444  * this string must be freed by m_free.
1445  */
1446 char*
1447 get_user_id_string( u32 *keyid )
1448 {
1449     user_id_db_t r;
1450     char *p;
1451     int pass=0;
1452     /* try it two times; second pass reads from key resources */
1453     do {
1454         for(r=user_id_db; r; r = r->next )
1455             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1456                 p = m_alloc( r->len + 10 );
1457                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1458                 return p;
1459             }
1460     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1461     p = m_alloc( 15 );
1462     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1463     return p;
1464 }
1465
1466 char*
1467 get_long_user_id_string( u32 *keyid )
1468 {
1469     user_id_db_t r;
1470     char *p;
1471     int pass=0;
1472     /* try it two times; second pass reads from key resources */
1473     do {
1474         for(r=user_id_db; r; r = r->next )
1475             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1476                 p = m_alloc( r->len + 20 );
1477                 sprintf(p, "%08lX%08lX %.*s",
1478                           (ulong)keyid[0], (ulong)keyid[1], r->len, r->name );
1479                 return p;
1480             }
1481     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1482     p = m_alloc( 25 );
1483     sprintf(p, "%08lX%08lX [?]", (ulong)keyid[0], (ulong)keyid[1] );
1484     return p;
1485 }
1486
1487 char*
1488 get_user_id( u32 *keyid, size_t *rn )
1489 {
1490     user_id_db_t r;
1491     char *p;
1492     int pass=0;
1493     /* try it two times; second pass reads from key resources */
1494     do {
1495         for(r=user_id_db; r; r = r->next )
1496             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1497                 p = m_alloc( r->len );
1498                 memcpy(p, r->name, r->len );
1499                 *rn = r->len;
1500                 return p;
1501             }
1502     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1503     p = m_alloc( 19 );
1504     memcpy(p, "[User id not found]", 19 );
1505     *rn = 19;
1506     return p;
1507 }
1508
1509