*** empty log message ***
[gnupg.git] / g10 / getkey.c
1 /* getkey.c -  Get a key from the database
2  *      Copyright (C) 1998 Free Software Foundation, Inc.
3  *
4  * This file is part of GNUPG.
5  *
6  * GNUPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GNUPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <assert.h>
26 #include <ctype.h>
27 #include "util.h"
28 #include "packet.h"
29 #include "memory.h"
30 #include "iobuf.h"
31 #include "keydb.h"
32 #include "options.h"
33 #include "main.h"
34 #include "i18n.h"
35
36 #define MAX_PK_CACHE_ENTRIES 500
37
38
39 typedef struct keyid_list {
40     struct keyid_list *next;
41     u32 keyid[2];
42 } *keyid_list_t;
43
44 typedef struct user_id_db {
45     struct user_id_db *next;
46     u32 keyid[2];
47     int len;
48     char name[1];
49 } *user_id_db_t;
50
51 typedef struct pk_cache_entry {
52     struct pk_cache_entry *next;
53     u32 keyid[2];
54     PKT_public_key *pk;
55 } *pk_cache_entry_t;
56
57 typedef struct enum_seckey_context {
58     int eof;
59     STRLIST sl;
60     IOBUF iobuf;
61 } enum_seckey_context_t;
62
63
64 static STRLIST keyrings;
65 static STRLIST secret_keyrings;
66
67 static keyid_list_t unknown_keyids;
68 static user_id_db_t user_id_db;
69 static pk_cache_entry_t pk_cache;
70 static int pk_cache_entries;   /* number of entries in pk cache */
71
72
73 static int lookup( PKT_public_key *pk,
74                    int mode,  u32 *keyid, const char *name,
75                    KBNODE *ret_keyblock, int primary  );
76 static int lookup_sk( PKT_secret_key *sk,
77                    int mode,  u32 *keyid, const char *name, int primary );
78
79 /* note this function may be called before secure memory is
80  * available
81  * The first keyring which is added by this function is
82  * created if it does not exist.
83  */
84 void
85 add_keyring( const char *name )
86 {
87     STRLIST sl;
88     int rc, force = !keyrings;
89
90     if( *name != '/' ) { /* do tilde expansion etc */
91         char *p ;
92
93         if( strchr(name, '/') )
94             p = make_filename(name, NULL);
95         else
96             p = make_filename(opt.homedir, name, NULL);
97         sl = append_to_strlist( &keyrings, p );
98         m_free(p);
99     }
100     else
101         sl = append_to_strlist( &keyrings, name );
102
103     /* fixme: We should remove much out of this module and
104      * combine it with the keyblock stuff from ringedit.c
105      * For now we will simple add the filename as keyblock resource
106      */
107     rc = add_keyblock_resource( sl->d, force, 0 );
108     if( rc )
109         log_error("keyblock resource '%s': %s\n", sl->d, g10_errstr(rc) );
110 }
111
112
113 /****************
114  * Get the name of the keyrings, start with a sequence number of 0.
115  */
116 const char *
117 get_keyring( int sequence )
118 {
119     STRLIST sl;
120
121     for(sl = keyrings; sl && sequence; sl = sl->next, sequence-- )
122         ;
123     return sl? sl->d : NULL;
124 }
125
126 const char *
127 get_secret_keyring( int sequence )
128 {
129     STRLIST sl;
130
131     for(sl = secret_keyrings; sl && sequence; sl = sl->next, sequence-- )
132         ;
133     return sl? sl->d : NULL;
134 }
135
136
137 void
138 add_secret_keyring( const char *name )
139 {
140     STRLIST sl;
141     int rc, force = !secret_keyrings;
142
143     if( *name != '/' ) { /* do tilde expansion etc */
144         char *p ;
145
146         if( strchr(name, '/') )
147             p = make_filename(name, NULL);
148         else
149             p = make_filename(opt.homedir, name, NULL);
150         sl = append_to_strlist( &secret_keyrings, p );
151         m_free(p);
152     }
153     else
154         sl = append_to_strlist( &secret_keyrings, name );
155
156     /* fixme: We should remove much out of this module and
157      * combine it with the keyblock stuff from ringedit.c
158      * For now we will simple add the filename as keyblock resource
159      */
160     rc = add_keyblock_resource( sl->d, force, 1 );
161     if( rc )
162         log_error("secret keyblock resource '%s': %s\n", sl->d, g10_errstr(rc));
163 }
164
165
166 static void
167 cache_public_key( PKT_public_key *pk )
168 {
169     pk_cache_entry_t ce;
170     u32 keyid[2];
171
172     if( is_ELGAMAL(pk->pubkey_algo)
173         || pk->pubkey_algo == PUBKEY_ALGO_DSA
174         || is_RSA(pk->pubkey_algo) ) {
175         keyid_from_pk( pk, keyid );
176     }
177     else
178         return; /* don't know how to get the keyid */
179
180     for( ce = pk_cache; ce; ce = ce->next )
181         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
182             if( DBG_CACHE )
183                 log_debug("cache_public_key: already in cache\n");
184             return;
185         }
186
187     if( pk_cache_entries > MAX_PK_CACHE_ENTRIES ) {
188         /* FIMXE: use another algorithm to free some cache slots */
189         if( pk_cache_entries == MAX_PK_CACHE_ENTRIES )  {
190             pk_cache_entries++;
191             log_info("too many entries in pk cache - disabled\n");
192         }
193         ce = pk_cache;
194         free_public_key( ce->pk );
195     }
196     else {
197         pk_cache_entries++;
198         ce = m_alloc( sizeof *ce );
199         ce->next = pk_cache;
200         pk_cache = ce;
201     }
202     ce->pk = copy_public_key( NULL, pk );
203     ce->keyid[0] = keyid[0];
204     ce->keyid[1] = keyid[1];
205 }
206
207
208 /****************
209  * Store the association of keyid and userid
210  */
211 void
212 cache_user_id( PKT_user_id *uid, u32 *keyid )
213 {
214     user_id_db_t r;
215
216     for(r=user_id_db; r; r = r->next )
217         if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
218             if( DBG_CACHE )
219                log_debug("cache_user_id: already in cache\n");
220             return;
221         }
222
223     r = m_alloc( sizeof *r + uid->len-1 );
224     r->keyid[0] = keyid[0];
225     r->keyid[1] = keyid[1];
226     r->len = uid->len;
227     memcpy(r->name, uid->name, r->len);
228     r->next = user_id_db;
229     user_id_db = r;
230 }
231
232
233
234 /****************
235  * Get a public key and store it into the allocated pk
236  * can be called with PK set to NULL to just read it into some
237  * internal structures.
238  */
239 int
240 get_pubkey( PKT_public_key *pk, u32 *keyid )
241 {
242     keyid_list_t kl;
243     int internal = 0;
244     int rc = 0;
245     pk_cache_entry_t ce;
246
247     /* let's see whether we checked the keyid already */
248     for( kl = unknown_keyids; kl; kl = kl->next )
249         if( kl->keyid[0] == keyid[0] && kl->keyid[1] == keyid[1] )
250             return G10ERR_NO_PUBKEY; /* already checked and not found */
251
252     /* Try to get it from our cache */
253     for( ce = pk_cache; ce; ce = ce->next )
254         if( ce->keyid[0] == keyid[0] && ce->keyid[1] == keyid[1] ) {
255             if( pk )
256                 copy_public_key( pk, ce->pk );
257             return 0;
258         }
259     /* more init stuff */
260     if( !pk ) {
261         pk = m_alloc_clear( sizeof *pk );
262         internal++;
263     }
264
265
266     /* do a lookup */
267     rc = lookup( pk, 11, keyid, NULL, NULL, 0 );
268     if( !rc )
269         goto leave;
270
271     /* not found: store it for future reference */
272     kl = m_alloc( sizeof *kl );
273     kl->keyid[0] = keyid[0];
274     kl->keyid[1] = keyid[1];
275     kl->next = unknown_keyids;
276     unknown_keyids = kl;
277     rc = G10ERR_NO_PUBKEY;
278
279   leave:
280     if( !rc )
281         cache_public_key( pk );
282     if( internal )
283         m_free(pk);
284     return rc;
285 }
286
287
288 static int
289 hextobyte( const byte *s )
290 {
291     int c;
292
293     if( *s >= '0' && *s <= '9' )
294         c = 16 * (*s - '0');
295     else if( *s >= 'A' && *s <= 'F' )
296         c = 16 * (10 + *s - 'A');
297     else if( *s >= 'a' && *s <= 'f' )
298         c = 16 * (10 + *s - 'a');
299     else
300         return -1;
301     s++;
302     if( *s >= '0' && *s <= '9' )
303         c += *s - '0';
304     else if( *s >= 'A' && *s <= 'F' )
305         c += 10 + *s - 'A';
306     else if( *s >= 'a' && *s <= 'f' )
307         c += 10 + *s - 'a';
308     else
309         return -1;
310     return c;
311 }
312
313
314 /****************
315  * Try to get the pubkey by the userid. This function looks for the
316  * first pubkey certificate which has the given name in a user_id.
317  * if pk has the pubkey algo set, the function will only return
318  * a pubkey with that algo.
319  *
320  * - If the username starts with 8,9,16 or 17 hex-digits (the first one
321  *   must be in the range 0..9), this is considered a keyid; depending
322  *   on the length a short or complete one.
323  * - If the username starts with 32,33,40 or 41 hex-digits (the first one
324  *   must be in the range 0..9), this is considered a fingerprint.
325  * - If the username starts with a left angle, we assume it is a complete
326  *   email address and look only at this part.
327  * - If the username starts with a '.', we assume it is the ending
328  *   part of an email address
329  * - If the username starts with an '@', we assume it is a part of an
330  *   email address
331  * - If the userid start with an '=' an exact compare is done.
332  * - If the userid starts with a '*' a case insensitive substring search is
333  *   done (This is also the default).
334  */
335
336
337 static int
338 key_byname( int secret,
339             PKT_public_key *pk, PKT_secret_key *sk, const char *name )
340 {
341     int internal = 0;
342     int rc = 0;
343     const char *s;
344     u32 keyid[2] = {0}; /* init to avoid compiler warning */
345     byte fprint[20];
346     int mode = 0;
347
348     /* check what kind of name it is */
349     for(s = name; *s && isspace(*s); s++ )
350         ;
351     if( isdigit( *s ) ) { /* a keyid or a fingerprint */
352         int i, j;
353         char buf[9];
354
355         if( *s == '0' && s[1] == 'x' && isxdigit(s[2]) )
356             s += 2; /*kludge to allow 0x034343434 */
357         for(i=0; isxdigit(s[i]); i++ )
358             ;
359         if( s[i] && !isspace(s[i]) ) /* not terminated by EOS or blank*/
360             rc = G10ERR_INV_USER_ID;
361         else if( i == 8 || (i == 9 && *s == '0') ) { /* short keyid */
362             if( i==9 )
363                 s++;
364             keyid[1] = strtoul( s, NULL, 16 );
365             mode = 10;
366         }
367         else if( i == 16 || (i == 17 && *s == '0') ) { /* complete keyid */
368             if( i==17 )
369                 s++;
370             mem2str(buf, s, 9 );
371             keyid[0] = strtoul( buf, NULL, 16 );
372             keyid[1] = strtoul( s+8, NULL, 16 );
373             mode = 11;
374         }
375         else if( i == 32 || ( i == 33 && *s == '0' ) ) { /* md5 fingerprint */
376             if( i==33 )
377                 s++;
378             memset(fprint+16, 4, 0);
379             for(j=0; !rc && j < 16; j++, s+=2 ) {
380                 int c = hextobyte( s );
381                 if( c == -1 )
382                     rc = G10ERR_INV_USER_ID;
383                 else
384                     fprint[j] = c;
385             }
386             mode = 16;
387         }
388         else if( i == 40 || ( i == 41 && *s == '0' ) ) { /* sha1/rmd160 fprint*/
389             if( i==33 )
390                 s++;
391             for(j=0; !rc && j < 20; j++, s+=2 ) {
392                 int c = hextobyte( s );
393                 if( c == -1 )
394                     rc = G10ERR_INV_USER_ID;
395                 else
396                     fprint[j] = c;
397             }
398             mode = 20;
399         }
400         else
401             rc = G10ERR_INV_USER_ID;
402     }
403     else if( *s == '=' ) { /* exact search */
404         mode = 1;
405         s++;
406     }
407     else if( *s == '*' ) { /* substring search */
408         mode = 2;
409         s++;
410     }
411     else if( *s == '<' ) { /* an email address */
412         mode = 3;
413     }
414     else if( *s == '@' ) { /* a part of an email address */
415         mode = 4;
416         s++;
417     }
418     else if( *s == '.' ) { /* an email address, compare from end */
419         mode = 5;
420         s++;
421     }
422     else if( *s == '#' ) { /* use local id */
423         rc = G10ERR_INV_USER_ID; /* not yet implemented */
424     }
425     else if( !*s )  /* empty string */
426         rc = G10ERR_INV_USER_ID;
427     else
428         mode = 2;
429
430     if( rc )
431         goto leave;
432
433     if( secret ) {
434         if( !sk ) {
435             sk = m_alloc_clear( sizeof *sk );
436             internal++;
437         }
438         rc = mode < 16? lookup_sk( sk, mode, keyid, s, 1 )
439                       : lookup_sk( sk, mode, keyid, fprint, 1 );
440     }
441     else {
442         if( !pk ) {
443             pk = m_alloc_clear( sizeof *pk );
444             internal++;
445         }
446         rc = mode < 16? lookup( pk, mode, keyid, s, NULL, 1 )
447                       : lookup( pk, mode, keyid, fprint, NULL, 1 );
448     }
449
450
451   leave:
452     if( internal && secret )
453         m_free( sk );
454     else if( internal )
455         m_free( pk );
456     return rc;
457 }
458
459 int
460 get_pubkey_byname( PKT_public_key *pk, const char *name )
461 {
462     return key_byname( 0, pk, NULL, name );
463 }
464
465
466 /****************
467  * Search for a key with the given fingerprint.
468  */
469 int
470 get_pubkey_byfprint( PKT_public_key *pk, const byte *fprint, size_t fprint_len)
471 {
472     int rc;
473
474     if( fprint_len == 20 || fprint_len == 16 )
475         rc = lookup( pk, fprint_len, NULL, fprint, NULL, 0 );
476     else
477         rc = G10ERR_GENERAL; /* Oops */
478     return rc;
479 }
480
481 /****************
482  * Search for a key with the given fingerprint and return the
483  * complete keyblock which may have more than only this key.
484  */
485 int
486 get_keyblock_byfprint( KBNODE *ret_keyblock, const byte *fprint,
487                                                 size_t fprint_len )
488 {
489     int rc;
490     PKT_public_key *pk = m_alloc_clear( sizeof *pk );
491
492     if( fprint_len == 20 || fprint_len == 16 )
493         rc = lookup( pk, fprint_len, NULL, fprint, ret_keyblock, 0 );
494     else
495         rc = G10ERR_GENERAL; /* Oops */
496
497     free_public_key( pk );
498     return rc;
499 }
500
501 /****************
502  * Get a secret key and store it into sk
503  */
504 int
505 get_seckey( PKT_secret_key *sk, u32 *keyid )
506 {
507     int rc;
508
509     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
510     if( !rc ) {
511         /* check the secret key (this may prompt for a passprase to
512          * unlock the secret key
513          */
514         rc = check_secret_key( sk, 0 );
515     }
516
517     return rc;
518 }
519
520 /****************
521  * Check whether the secret key is available
522  * Returns: 0 := key is available
523  *          G10ERR_NO_SECKEY := not availabe
524  */
525 int
526 seckey_available( u32 *keyid )
527 {
528     PKT_secret_key *sk;
529     int rc;
530
531     sk = m_alloc_clear( sizeof *sk );
532     rc = lookup_sk( sk, 11, keyid, NULL, 0 );
533     free_secret_key( sk );
534     return rc;
535 }
536
537
538
539 /****************
540  * Get a secret key by name and store it into sk
541  * If NAME is NULL use the default key
542  */
543 int
544 get_seckey_byname( PKT_secret_key *sk, const char *name, int unprotect )
545 {
546     int rc;
547
548     if( !name && opt.def_secret_key && *opt.def_secret_key )
549         rc = key_byname( 1, NULL, sk, opt.def_secret_key );
550     else if( !name ) /* use the first one as default key */
551         rc = lookup_sk( sk, 15, NULL, NULL, 1 );
552     else
553         rc = key_byname( 1, NULL, sk, name );
554     if( !rc && unprotect )
555         rc = check_secret_key( sk, 0 );
556
557     return rc;
558 }
559
560
561 static int
562 compare_name( const char *uid, size_t uidlen, const char *name, int mode )
563 {
564     int i;
565     const char *s, *se;
566
567     if( mode == 1 ) {  /* exact match */
568         for(i=0; name[i] && uidlen; i++, uidlen-- )
569             if( uid[i] != name[i] )
570                 break;
571         if( !uidlen && !name[i] )
572             return 0; /* found */
573     }
574     else if( mode == 2 ) { /* case insensitive substring */
575         if( memistr( uid, uidlen, name ) )
576             return 0;
577     }
578     else if( mode >= 3 && mode <= 5 ) { /* look at the email address */
579         for( i=0, s= uid; i < uidlen && *s != '<'; s++, i++ )
580             ;
581         if( i < uidlen )  {
582             /* skip opening delim and one char and look for the closing one*/
583             s++; i++;
584             for( se=s+1, i++; i < uidlen && *se != '>'; se++, i++ )
585                 ;
586             if( i < uidlen ) {
587                 i = se - s;
588                 if( mode == 3 ) { /* exact email address */
589                     if( strlen(name)-2 == i && !memicmp( s, name+1, i) )
590                         return 0;
591                 }
592                 else if( mode == 4 ) {  /* email substring */
593                     if( memistr( s, i, name ) )
594                         return 0;
595                 }
596                 else { /* email from end */
597                     /* nyi */
598                 }
599             }
600         }
601     }
602     else
603         BUG();
604
605     return -1; /* not found */
606 }
607
608
609
610 /****************
611  * Assume that knode points to a public key packet  and keyblock is
612  * the entire keyblock.  This function adds all relevant information from
613  * a selfsignature to the public key.
614  */
615
616 static void
617 merge_one_pk_and_selfsig( KBNODE keyblock, KBNODE knode )
618 {
619     PKT_public_key *pk = knode->pkt->pkt.public_key;
620     PKT_signature *sig;
621     KBNODE k;
622     u32 kid[2];
623
624     assert(    knode->pkt->pkttype == PKT_PUBLIC_KEY
625             || knode->pkt->pkttype == PKT_PUBLIC_SUBKEY );
626
627     if( pk->version < 4 )
628         return; /* this is only needed for version >=4 packets */
629
630     /* find the selfsignature */
631     if( knode->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
632         k = find_kbnode( keyblock, PKT_PUBLIC_KEY );
633         if( !k )
634            BUG(); /* keyblock without primary key!!! */
635         keyid_from_pk( knode->pkt->pkt.public_key, kid );
636     }
637     else
638         keyid_from_pk( pk, kid );
639     for(k=keyblock; k; k = k->next ) {
640         if( k->pkt->pkttype == PKT_SIGNATURE
641             && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
642             && sig->sig_class <= 0x13
643             && sig->keyid[0] == kid[0]
644             && sig->keyid[1] == kid[1]
645             && sig->version > 3 ) {
646             /* okay this is (the first) self-signature which can be used
647              * FIXME: We should only use this if the signature is valid
648              *        but this is time consuming - we must provide another
649              *        way to handle this
650              */
651             const byte *p;
652             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
653             pk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
654             /* fixme: add usage etc. to pk */
655             break;
656         }
657     }
658 }
659
660
661 /****************
662  * merge all selfsignatures with the keys.
663  */
664 void
665 merge_keys_and_selfsig( KBNODE keyblock )
666 {
667     PKT_public_key *pk = NULL;
668     PKT_secret_key *sk = NULL;
669     PKT_signature *sig;
670     KBNODE k;
671     u32 kid[2];
672
673     for(k=keyblock; k; k = k->next ) {
674         if( k->pkt->pkttype == PKT_PUBLIC_KEY
675             || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
676             pk = k->pkt->pkt.public_key; sk = NULL;
677             if( pk->version < 4 )
678                 pk = NULL; /* not needed for old keys */
679             else
680                 keyid_from_pk( pk, kid );
681         }
682         else if( k->pkt->pkttype == PKT_SECRET_KEY
683             || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
684             pk = NULL; sk = k->pkt->pkt.secret_key;
685             if( sk->version < 4 )
686                 sk = NULL;
687             else
688                 keyid_from_sk( sk, kid );
689         }
690         else if( (pk || sk ) && k->pkt->pkttype == PKT_SIGNATURE
691                  && (sig=k->pkt->pkt.signature)->sig_class >= 0x10
692                  && sig->sig_class <= 0x13 && sig->version > 3
693                  && sig->keyid[0] == kid[0] && sig->keyid[1] == kid[1] ) {
694             /* okay this is (the first) self-signature which can be used
695              * FIXME: We should only use this if the signature is valid
696              *        but this is time consuming - we must provide another
697              *        way to handle this
698              */
699             const byte *p;
700             p = parse_sig_subpkt( sig->hashed_data, SIGSUBPKT_KEY_EXPIRE, NULL );
701             if( pk ) {
702                 pk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
703                 /* fixme: add usage etc. */
704                 pk = NULL; /* use only the first self signature */
705             }
706             else {
707                 sk->valid_days = p? ((buffer_to_u32(p)+86399L)/86400L):0;
708                 sk = NULL; /* use only the first self signature */
709             }
710         }
711     }
712 }
713
714
715
716
717
718 /****************
719  * Lookup a key by scanning all keyrings
720  *   mode 1 = lookup by NAME (exact)
721  *        2 = lookup by NAME (substring)
722  *        3 = lookup by NAME (email address)
723  *        4 = email address (substring)
724  *        5 = email address (compare from end)
725  *       10 = lookup by short KEYID (don't care about keyid[0])
726  *       11 = lookup by long  KEYID
727  *       15 = Get the first key.
728  *       16 = lookup by 16 byte fingerprint which is stored in NAME
729  *       20 = lookup by 20 byte fingerprint which is stored in NAME
730  * Caller must provide an empty PK, if the pubkey_algo is filled in, only
731  * a key of this algo will be returned.
732  * If ret_keyblock is not NULL, the complete keyblock is returned also
733  * and the caller must release it.
734  */
735 static int
736 lookup( PKT_public_key *pk, int mode,  u32 *keyid,
737         const char *name, KBNODE *ret_keyblock, int primary )
738 {
739     int rc;
740     KBNODE keyblock = NULL;
741     KBPOS kbpos;
742     int oldmode = set_packet_list_mode(0);
743     byte namehash[20];
744     int use_namehash=0;
745
746     rc = enum_keyblocks( 0, &kbpos, &keyblock );
747     if( rc ) {
748         if( rc == -1 )
749             rc = G10ERR_NO_PUBKEY;
750         else if( rc )
751             log_error("enum_keyblocks(open) failed: %s\n", g10_errstr(rc) );
752         goto leave;
753     }
754
755     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
756         KBNODE k, kk;
757         if( mode < 10 ) { /* name lookup */
758             for(k=keyblock; k; k = k->next ) {
759                 if( k->pkt->pkttype == PKT_USER_ID
760                     && !compare_name( k->pkt->pkt.user_id->name,
761                                       k->pkt->pkt.user_id->len, name, mode)) {
762                     /* we found a matching name, look for the key */
763                     for(kk=keyblock; kk; kk = kk->next ) {
764                         if( (    kk->pkt->pkttype == PKT_PUBLIC_KEY
765                               || kk->pkt->pkttype == PKT_PUBLIC_SUBKEY )
766                             && ( !pk->pubkey_algo
767                                  || pk->pubkey_algo
768                                     == kk->pkt->pkt.public_key->pubkey_algo)
769                             && ( !pk->pubkey_usage
770                                  || !check_pubkey_algo2(
771                                        kk->pkt->pkt.public_key->pubkey_algo,
772                                                            pk->pubkey_usage ))
773                           )
774                             break;
775                     }
776                     if( kk ) {
777                         u32 aki[2];
778                         keyid_from_pk( kk->pkt->pkt.public_key, aki );
779                         cache_user_id( k->pkt->pkt.user_id, aki );
780                         rmd160_hash_buffer( namehash,
781                                             k->pkt->pkt.user_id->name,
782                                             k->pkt->pkt.user_id->len );
783                         use_namehash = 1;
784                         k = kk;
785                         break;
786                     }
787                     else
788                         log_error("No key for userid\n");
789                 }
790             }
791         }
792         else { /* keyid or fingerprint lookup */
793             if( DBG_CACHE && (mode== 10 || mode==11) ) {
794                 log_debug("lookup keyid=%08lx%08lx req_algo=%d mode=%d\n",
795                                 (ulong)keyid[0], (ulong)keyid[1],
796                                  pk->pubkey_algo, mode );
797             }
798             for(k=keyblock; k; k = k->next ) {
799                 if(    k->pkt->pkttype == PKT_PUBLIC_KEY
800                     || k->pkt->pkttype == PKT_PUBLIC_SUBKEY ) {
801                     if( mode == 10 || mode == 11 ) {
802                         u32 aki[2];
803                         keyid_from_pk( k->pkt->pkt.public_key, aki );
804                         if( DBG_CACHE ) {
805                             log_debug("         aki=%08lx%08lx algo=%d\n",
806                                             (ulong)aki[0], (ulong)aki[1],
807                                     k->pkt->pkt.public_key->pubkey_algo    );
808                         }
809                         if( aki[1] == keyid[1]
810                             && ( mode == 10 || aki[0] == keyid[0] )
811                             && ( !pk->pubkey_algo
812                                  || pk->pubkey_algo
813                                     == k->pkt->pkt.public_key->pubkey_algo) ){
814                             /* cache the userid */
815                             for(kk=keyblock; kk; kk = kk->next )
816                                 if( kk->pkt->pkttype == PKT_USER_ID )
817                                     break;
818                             if( kk )
819                                 cache_user_id( kk->pkt->pkt.user_id, aki );
820                             else
821                                 log_error("No userid for key\n");
822                             break; /* found */
823                         }
824                     }
825                     else if( mode == 15 ) { /* get the first key */
826                         if( !pk->pubkey_algo
827                             || pk->pubkey_algo
828                                   == k->pkt->pkt.public_key->pubkey_algo )
829                             break;
830                     }
831                     else if( mode == 16 || mode == 20 ) {
832                         size_t an;
833                         byte *afp = fingerprint_from_pk(
834                                         k->pkt->pkt.public_key, NULL, &an );
835
836                         if( DBG_CACHE ) {
837                             u32 aki[2];
838                             keyid_from_pk( k->pkt->pkt.public_key, aki );
839                             log_debug("         aki=%08lx%08lx algo=%d mode=%d an=%u\n",
840                                             (ulong)aki[0], (ulong)aki[1],
841                                     k->pkt->pkt.public_key->pubkey_algo,
842                                                         mode, an );
843                         }
844                         if( an == mode && !memcmp( afp, name, an)
845                             && ( !pk->pubkey_algo
846                                  || pk->pubkey_algo
847                                     == k->pkt->pkt.public_key->pubkey_algo) ) {
848                             m_free(afp);
849                             break;
850                         }
851                         m_free(afp);
852                     }
853                     else
854                         BUG();
855                 } /* end compare public keys */
856             }
857         }
858         if( k ) { /* found */
859             assert(    k->pkt->pkttype == PKT_PUBLIC_KEY
860                     || k->pkt->pkttype == PKT_PUBLIC_SUBKEY );
861             assert( keyblock->pkt->pkttype == PKT_PUBLIC_KEY );
862             if( primary && !pk->pubkey_usage ) {
863                 copy_public_key_new_namehash( pk, keyblock->pkt->pkt.public_key,
864                                               use_namehash? namehash:NULL);
865                 merge_one_pk_and_selfsig( keyblock, keyblock );
866             }
867             else {
868                 if( primary && pk->pubkey_usage
869                     && check_pubkey_algo2( k->pkt->pkt.public_key->pubkey_algo,
870                                pk->pubkey_usage ) == G10ERR_WR_PUBKEY_ALGO ) {
871                     /* if the usage is not correct, try to use a subkey */
872                     KBNODE save_k = k;
873
874                     for( ; k; k = k->next ) {
875                         if( k->pkt->pkttype == PKT_PUBLIC_SUBKEY
876                             && !check_pubkey_algo2(
877                                     k->pkt->pkt.public_key->pubkey_algo,
878                                                      pk->pubkey_usage ) )
879                             break;
880                     }
881                     if( !k )
882                         k = save_k;
883                     else
884                         log_info(_("using secondary key %08lX "
885                                    "instead of primary key %08lX\n"),
886                       (ulong)keyid_from_pk( k->pkt->pkt.public_key, NULL),
887                       (ulong)keyid_from_pk( save_k->pkt->pkt.public_key, NULL)
888                                 );
889                 }
890
891                 copy_public_key_new_namehash( pk, k->pkt->pkt.public_key,
892                                               use_namehash? namehash:NULL);
893                 merge_one_pk_and_selfsig( keyblock, k );
894             }
895             if( ret_keyblock ) {
896                 *ret_keyblock = keyblock;
897                 keyblock = NULL;
898             }
899             break; /* enumeration */
900         }
901         release_kbnode( keyblock );
902         keyblock = NULL;
903     }
904     if( rc == -1 )
905         rc = G10ERR_NO_PUBKEY;
906     else if( rc )
907         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
908
909   leave:
910     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
911     release_kbnode( keyblock );
912     set_packet_list_mode(oldmode);
913     return rc;
914 }
915
916 /****************
917  * Ditto for secret keys
918  */
919 static int
920 lookup_sk( PKT_secret_key *sk, int mode,  u32 *keyid, const char *name,
921            int primary )
922 {
923     int rc;
924     KBNODE keyblock = NULL;
925     KBPOS kbpos;
926     int oldmode = set_packet_list_mode(0);
927
928     rc = enum_keyblocks( 5 /* open secret */, &kbpos, &keyblock );
929     if( rc ) {
930         if( rc == -1 )
931             rc = G10ERR_NO_SECKEY;
932         else if( rc )
933             log_error("enum_keyblocks(open secret) failed: %s\n", g10_errstr(rc) );
934         goto leave;
935     }
936
937     while( !(rc = enum_keyblocks( 1, &kbpos, &keyblock )) ) {
938         KBNODE k, kk;
939         if( mode < 10 ) { /* name lookup */
940             for(k=keyblock; k; k = k->next ) {
941                 if( k->pkt->pkttype == PKT_USER_ID
942                     && !compare_name( k->pkt->pkt.user_id->name,
943                                       k->pkt->pkt.user_id->len, name, mode)) {
944                     /* we found a matching name, look for the key */
945                     for(kk=keyblock; kk; kk = kk->next ) {
946                         if( (    kk->pkt->pkttype == PKT_SECRET_KEY
947                               || kk->pkt->pkttype == PKT_SECRET_SUBKEY )
948                             && ( !sk->pubkey_algo
949                                  || sk->pubkey_algo
950                                     == kk->pkt->pkt.secret_key->pubkey_algo)
951                             && ( !sk->pubkey_usage
952                                  || !check_pubkey_algo2(
953                                        kk->pkt->pkt.secret_key->pubkey_algo,
954                                                            sk->pubkey_usage ))
955                           )
956                             break;
957                     }
958                     if( kk ) {
959                         u32 aki[2];
960                         keyid_from_sk( kk->pkt->pkt.secret_key, aki );
961                         cache_user_id( k->pkt->pkt.user_id, aki );
962                         k = kk;
963                         break;
964                     }
965                     else
966                         log_error("No key for userid (in sk)\n");
967                 }
968             }
969         }
970         else { /* keyid or fingerprint lookup */
971             if( DBG_CACHE && (mode== 10 || mode==11) ) {
972                 log_debug("lookup_sk keyid=%08lx%08lx req_algo=%d mode=%d\n",
973                                 (ulong)keyid[0], (ulong)keyid[1],
974                                  sk->pubkey_algo, mode );
975             }
976             for(k=keyblock; k; k = k->next ) {
977                 if(    k->pkt->pkttype == PKT_SECRET_KEY
978                     || k->pkt->pkttype == PKT_SECRET_SUBKEY ) {
979                     if( mode == 10 || mode == 11 ) {
980                         u32 aki[2];
981                         keyid_from_sk( k->pkt->pkt.secret_key, aki );
982                         if( DBG_CACHE ) {
983                             log_debug("             aki=%08lx%08lx algo=%d\n",
984                                             (ulong)aki[0], (ulong)aki[1],
985                                     k->pkt->pkt.secret_key->pubkey_algo    );
986                         }
987                         if( aki[1] == keyid[1]
988                             && ( mode == 10 || aki[0] == keyid[0] )
989                             && ( !sk->pubkey_algo
990                                  || sk->pubkey_algo
991                                     == k->pkt->pkt.secret_key->pubkey_algo) ){
992                             /* cache the userid */
993                             for(kk=keyblock; kk; kk = kk->next )
994                                 if( kk->pkt->pkttype == PKT_USER_ID )
995                                     break;
996                             if( kk )
997                                 cache_user_id( kk->pkt->pkt.user_id, aki );
998                             else
999                                 log_error("No userid for key\n");
1000                             break; /* found */
1001                         }
1002                     }
1003                     else if( mode == 15 ) { /* get the first key */
1004                         if( !sk->pubkey_algo
1005                             || sk->pubkey_algo
1006                                   == k->pkt->pkt.secret_key->pubkey_algo )
1007                             break;
1008                     }
1009                     else if( mode == 16 || mode == 20 ) {
1010                         size_t an;
1011                         byte *afp = fingerprint_from_sk(
1012                                         k->pkt->pkt.secret_key, NULL, &an );
1013                         if( an == mode && !memcmp( afp, name, an)
1014                             && ( !sk->pubkey_algo
1015                                  || sk->pubkey_algo
1016                                     == k->pkt->pkt.secret_key->pubkey_algo) ) {
1017                             m_free(afp);
1018                             break;
1019                         }
1020                         m_free(afp);
1021                     }
1022                     else
1023                         BUG();
1024                 } /* end compare secret keys */
1025             }
1026         }
1027         if( k ) { /* found */
1028             assert(    k->pkt->pkttype == PKT_SECRET_KEY
1029                     || k->pkt->pkttype == PKT_SECRET_SUBKEY );
1030             assert( keyblock->pkt->pkttype == PKT_SECRET_KEY );
1031             if( primary && !sk->pubkey_usage )
1032                 copy_secret_key( sk, keyblock->pkt->pkt.secret_key );
1033             else
1034                 copy_secret_key( sk, k->pkt->pkt.secret_key );
1035             break; /* enumeration */
1036         }
1037         release_kbnode( keyblock );
1038         keyblock = NULL;
1039     }
1040     if( rc == -1 )
1041         rc = G10ERR_NO_SECKEY;
1042     else if( rc )
1043         log_error("enum_keyblocks(read) failed: %s\n", g10_errstr(rc));
1044
1045   leave:
1046     enum_keyblocks( 2, &kbpos, &keyblock ); /* close */
1047     release_kbnode( keyblock );
1048     set_packet_list_mode(oldmode);
1049     return rc;
1050 }
1051
1052
1053
1054 /****************
1055  * Enumerate all primary secret keys.  Caller must use these procedure:
1056  *  1) create a void pointer and initialize it to NULL
1057  *  2) pass this void pointer by reference to this function
1058  *     and provide space for the secret key (pass a buffer for sk)
1059  *  3) call this function as long as it does not return -1
1060  *     to indicate EOF.
1061  *  4) Always call this function a last time with SK set to NULL,
1062  *     so that can free it's context.
1063  *
1064  *
1065  */
1066 int
1067 enum_secret_keys( void **context, PKT_secret_key *sk, int with_subkeys )
1068 {
1069     int rc=0;
1070     PACKET pkt;
1071     int save_mode;
1072     enum_seckey_context_t *c = *context;
1073
1074     if( !c ) { /* make a new context */
1075         c = m_alloc_clear( sizeof *c );
1076         *context = c;
1077         c->sl = secret_keyrings;
1078     }
1079
1080     if( !sk ) { /* free the context */
1081         m_free( c );
1082         *context = NULL;
1083         return 0;
1084     }
1085
1086     if( c->eof )
1087         return -1;
1088
1089     for( ; c->sl; c->sl = c->sl->next ) {
1090         if( !c->iobuf ) {
1091             if( !(c->iobuf = iobuf_open( c->sl->d ) ) ) {
1092                 log_error("enum_secret_keys: can't open '%s'\n", c->sl->d );
1093                 continue; /* try next file */
1094             }
1095         }
1096
1097         save_mode = set_packet_list_mode(0);
1098         init_packet(&pkt);
1099         while( (rc=parse_packet(c->iobuf, &pkt)) != -1 ) {
1100             if( rc )
1101                 ; /* e.g. unknown packet */
1102             else if( pkt.pkttype == PKT_SECRET_KEY
1103                      || ( with_subkeys && pkt.pkttype == PKT_SECRET_SUBKEY ) ) {
1104                 copy_secret_key( sk, pkt.pkt.secret_key );
1105                 set_packet_list_mode(save_mode);
1106                 return 0; /* found */
1107             }
1108             free_packet(&pkt);
1109         }
1110         set_packet_list_mode(save_mode);
1111         iobuf_close(c->iobuf); c->iobuf = NULL;
1112     }
1113     c->eof = 1;
1114     return -1;
1115 }
1116
1117
1118 /****************
1119  * Return a string with a printable representation of the user_id.
1120  * this string must be freed by m_free.
1121  */
1122 char*
1123 get_user_id_string( u32 *keyid )
1124 {
1125     user_id_db_t r;
1126     char *p;
1127     int pass=0;
1128     /* try it two times; second pass reads from keyrings */
1129     do {
1130         for(r=user_id_db; r; r = r->next )
1131             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1132                 p = m_alloc( r->len + 10 );
1133                 sprintf(p, "%08lX %.*s", (ulong)keyid[1], r->len, r->name );
1134                 return p;
1135             }
1136     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1137     p = m_alloc( 15 );
1138     sprintf(p, "%08lX [?]", (ulong)keyid[1] );
1139     return p;
1140 }
1141
1142 char*
1143 get_user_id( u32 *keyid, size_t *rn )
1144 {
1145     user_id_db_t r;
1146     char *p;
1147     int pass=0;
1148     /* try it two times; second pass reads from keyrings */
1149     do {
1150         for(r=user_id_db; r; r = r->next )
1151             if( r->keyid[0] == keyid[0] && r->keyid[1] == keyid[1] ) {
1152                 p = m_alloc( r->len );
1153                 memcpy(p, r->name, r->len );
1154                 *rn = r->len;
1155                 return p;
1156             }
1157     } while( ++pass < 2 && !get_pubkey( NULL, keyid ) );
1158     p = m_alloc( 19 );
1159     memcpy(p, "[User id not found]", 19 );
1160     *rn = 19;
1161     return p;
1162 }
1163
1164