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