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